added tests

dvm/tools/tester/trunk/test-suite/Correctness/C/ACROSS/acr11.cdv

@@ -0,0 +1,538 @@
+/*  ACR11
+
+    TESTING OF THE ACROSS CLAUSE'.
+    DISTRIBUTED ARRAY A(N) IS TO HAVE DIFFERENT
+    FLOW-DEP-LENGTH ON BOTH SIDES */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) (((a) < (b)) ? (a) : (b))
+
+static void acr1101();
+static void acr1102();
+static void acr1103();
+static void acr1104();
+static void acr1105();
+static void acr1106();
+static void acr1107();
+static void acr1108();
+static void acr1109();
+static void acr1110();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int i;
+
+int main(int an, char **as)
+{
+    printf("===START OF ACR11========================\n");
+    /* ---------------------------------------- */
+    acr1101();
+    /* ---------------------------------------- */
+    acr1102();
+    /* ---------------------------------------- */
+    acr1103();
+    /* ---------------------------------------- */
+    acr1104();
+    /* ---------------------------------------- */
+    acr1105();
+    /* ---------------------------------------- */
+    acr1106();
+    /* ---------------------------------------- */
+    acr1107();
+    /* ---------------------------------------- */
+    acr1108();
+    /* ---------------------------------------- */
+    acr1109();
+    /* ---------------------------------------- */
+    acr1110();
+    /* ---------------------------------------- */
+
+    printf("=== END OF ACR11 =========================\n");
+    return 0;
+}
+/* ---------------------------------------------ACR1101*/
+void acr1101()
+{
+    #define N 8
+    #define NL 1000
+    char tname[] = "ACR1101 ";
+    int nloop;
+    #pragma dvm array distribute[block]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 1; i < N - 1; i++)
+        C[i] = C[i - 1] + C[i + 1];
+
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[1:1])
+    for (i = 1; i < N - 1; i++)
+        A[i] = A[i - 1] + A[i + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 1; i < N - 1; i++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ---------------------------------------------ACR1102 */
+void acr1102()
+{
+    #define N 16
+    #define NL 1000
+    char tname[] = "ACR1102 ";
+    int nloop;
+    #pragma dvm array distribute[block]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 1; i < N - 1; i++)
+        C[i] = C[i] + C[i + 1];
+
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[0:1])
+    for (i = 1; i < N - 1; i++)
+        A[i] = A[i] + A[i + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 1; i < N - 1; i++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ---------------------------------------------ACR1103 */
+void acr1103()
+{
+    #define N 16
+    #define NL 1000
+    char tname[] = "ACR1103 ";
+    int nloop;
+    #pragma dvm array distribute[block]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 1; i < N - 1; i++)
+        C[i] = C[i - 1] + C[i];
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[1:0])
+    for (i = 1; i < N - 1; i++)
+        A[i] = A[i - 1] + A[i];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 1; i < N - 1; i++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ---------------------------------------------ACR1104 */
+void acr1104()
+{
+    #define N 16
+    #define NL 1000
+    char tname[] = "ACR1104 ";
+    int nloop;
+    #pragma dvm array distribute[block], shadow[2:2]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 2; i < N - 2; i++)
+        C[i] = C[i - 1] + C[i + 1] + C[i + 2] + C[i - 2];
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[2:2])
+    for (i = 2; i < N - 2; i++)
+        A[i] = A[i - 1] + A[i + 1] + A[i + 2] + A[i - 2];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 2; i < N - 2; i++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ---------------------------------------------ACR1105 */
+void acr1105()
+{
+    #define N 16
+    #define NL 1000
+    char tname[] = "ACR1105 ";
+    int nloop;
+    #pragma dvm array distribute[block], shadow[2:2]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 1; i < N - 2; i++)
+        C[i] = C[i + 1] + C[i + 2];
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[0:2])
+    for (i = 1; i < N - 2; i++)
+        A[i] = A[i + 1] + A[i + 2];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 1; i < N - 2; i++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ---------------------------------------------ACR1106 */
+void acr1106()
+{
+    #define N 16
+    #define NL 1000
+    char tname[] = "ACR1106 ";
+    int nloop;
+    #pragma dvm array distribute[block], shadow[2:2]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 2; i < N; i++)
+        C[i] = C[i - 1] + C[i - 2];
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[2:0])
+    for (i = 2; i < N; i++)
+        A[i] = A[i - 1] + A[i - 2];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 2; i < N; i++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ---------------------------------------------ACR1107 */
+void acr1107()
+{
+    #define N 16
+    #define NL 1000
+    char tname[] = "ACR1107 ";
+    int nloop;
+    #pragma dvm array distribute[block], shadow[3:3]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 3; i < N - 3; i++)
+        C[i] = C[i - 1] + C[i + 1] + C[i + 2] + C[i - 2] + C[i - 3] + C[i + 3];
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[3:3])
+    for (i = 3; i < N - 3; i ++)
+        A[i] = A[i - 1] + A[i + 1] + A[i + 2] + A[i - 2] + A[i - 3] + A[i + 3];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 3; i < N - 3; i ++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ---------------------------------------------ACR1108 */
+void acr1108()
+{
+    #define N 24
+    #define NL 1000
+    char tname[] = "ACR1108 ";
+    int nloop;
+    #pragma dvm array distribute[block], shadow[3:3]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 1; i < N - 3; i++)
+        C[i] = C[i + 1] + C[i + 2] + C[i + 3];
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[0:3])
+    for (i = 1; i < N - 3; i ++)
+        A[i] = A[i + 1] + A[i + 2] + A[i + 3];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 1; i < N - 3; i ++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ---------------------------------------------ACR1109 */
+void acr1109()
+{
+    #define N 24
+    #define NL 1000
+    char tname[] = "ACR1109 ";
+    int nloop;
+    #pragma dvm array distribute[block], shadow[3:3]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 3; i < N; i++)
+        C[i] = C[i - 1] + C[i - 2] + C[i - 3];
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[3:0])
+    for (i = 3; i < N; i ++)
+        A[i] = A[i - 1] + A[i - 2] + A[i - 3];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 3; i < N; i ++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ---------------------------------------------ACR1110 */
+void acr1110()
+{
+    #define N 60
+    #define NL 1000
+    char tname[] = "ACR1110 ";
+    int nloop;
+    #pragma dvm array distribute[block], shadow[11:11]
+    int *A;
+    A = (int (*))malloc(N * sizeof(int));
+    int *C;
+    C = (int (*))malloc(N * sizeof(int));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        C[i] = NNL + i;
+    nloop = NL;
+
+    for (i = 11; i < N - 11; i++)
+        C[i] = C[i - 9] + C[i + 9] + C[i + 10] + C[i - 10] + C[i - 11] + C[i + 11];
+    #pragma dvm actual(nloop)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) across(A[11:11])
+    for (i = 11; i < N - 11; i ++)
+        A[i] = A[i - 9] + A[i + 9] + A[i + 10] + A[i - 10] + A[i - 11] + A[i + 11];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloop))
+    for (i = 11; i < N - 11; i ++)
+        if (A[i] != C[i])
+            nloop = Min(nloop, i);
+    #pragma dvm get_actual(nloop)
+    if (nloop == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef N
+    #undef NL
+}
+/* ----------------------------------------------- */
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ACROSS/acr12.cdv

@@ -0,0 +1,939 @@
+/*  ACR12
+
+    TESTING OF THE ACROSS CLAUSE'.
+    DISTRIBUTED ARRAY A(N, M) IS TO HAVE 1 DISTRIBUTED DIMENSION AND DIFFERENT
+    FLOW-DEP-LENGTH ON BOTH SIDES */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) (((a) < (b)) ? (a) : (b))
+
+static void acr1201();
+static void acr1202();
+static void acr1203();
+static void acr1204();
+static void acr1205();
+static void acr1206();
+static void acr1207();
+static void acr1208();
+static void acr1209();
+static void acr1210();
+static void acr1211();
+static void acr1212();
+static void acr1213();
+static void acr1214();
+static void acr1215();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int i, j;
+
+int main(int an, char **as)
+{
+    printf("===START OF ACR12========================\n");
+    /* ---------------------------------------- */
+    acr1201();
+    /* ---------------------------------------- */
+    acr1202();
+    /* ---------------------------------------- */
+    acr1203();
+    /* ---------------------------------------- */
+    acr1204();
+    /* ---------------------------------------- */
+    acr1205();
+    /* ---------------------------------------- */
+    acr1206();
+    /* ---------------------------------------- */
+    acr1207();
+    /* ---------------------------------------- */
+    acr1208();
+    /* ---------------------------------------- */
+    acr1209();
+    /* ---------------------------------------- */
+    acr1210();
+    /* ---------------------------------------- */
+    acr1211();
+    /* ---------------------------------------- */
+    acr1212();
+    /* ---------------------------------------- */
+    acr1213();
+    /* ---------------------------------------- */
+    acr1214();
+    /* ---------------------------------------- */
+    acr1215();
+    /* ---------------------------------------- */
+
+    printf("=== END OF ACR12 =========================\n");
+    return 0;
+}
+/* ---------------------------------------------acr1201*/
+void acr1201()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1201 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[*][block]
+    int (*A)[M];
+    A = (int (*)[M])malloc(N * sizeof(int[M]));
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i + 1][j] + C[i][j + 1] + C[i - 1][j] + C[i][j - 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[1:1][1:1])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i + 1][j] + A[i][j + 1] + A[i - 1][j] + A[i][j - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1202*/
+void acr1202()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1202 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][*]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i + 1][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:1][0:0])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i + 1][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1203*/
+void acr1203()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1203 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[*][block]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i - 1][j] + C[i][j + 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[1:0][0:1])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i - 1][j] + A[i][j + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1204*/
+void acr1204()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1204 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][*], shadow[1:1][0:1]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i + 1][j] + C[i][j + 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:1][0:1])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i + 1][j] + A[i][j + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi, nloopj)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1205*/
+void acr1205()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1205 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[*][block], shadow[0:1][1:1]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i][j - 1] + C[i + 1][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:1][1:0])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i][j - 1] + A[i + 1][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1206*/
+void acr1206()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1206 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][*], shadow[2:2][2:2]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i + 2][j] + C[i][j + 2] + C[i + 2][j] + C[i - 2][j] + C[i][j - 2];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[2:2][2:2])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i + 2][j] + A[i][j + 2] + A[i + 2][j] + A[i - 2][j] + A[i][j - 2];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1207*/
+void acr1207()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1207 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[*][block], shadow[2:2][2:2]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i + 2][j] + C[i][j + 2] + C[i][j - 2];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:2][2:2])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i + 2][j] + A[i][j + 2] + A[i][j - 2];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1208*/
+void acr1208()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1208 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][*], shadow[2:2][2:2]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i - 1][j] + C[i][j - 1] + C[i - 2][j] + C[i + 2][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[2:2][2:0])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i - 1][j] + A[i][j - 1] + A[i - 2][j] + A[i + 2][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1209*/
+void acr1209()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1209 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[*][block], shadow[2:2][0:2]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i][j + 2] + C[i + 1][j] + C[i + 2][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[2:2][0:2])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i][j + 2] + A[i + 1][j] + A[i + 2][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1210*/
+void acr1210()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1210 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][*], shadow[3:3][3:3]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            C[i][j] = C[i + 1][j] + C[i][j + 2] + C[i + 3][j] + C[i][j -3 ] + C[i - 2][j] + C[i][j - 1];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[3:3][3:3])
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            A[i][j] = A[i + 1][j] + A[i][j + 2] + A[i + 3][j] + A[i][j - 3] + A[i - 2][j] + A[i][j - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1211*/
+void acr1211()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1211 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[*][block], shadow[3:3][0:3]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i][j] + C[i][j + 1];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:0][0:1])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i][j] + A[i][j + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1212*/
+void acr1212()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1212 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][*], shadow[0:3][3:3]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i][j] + C[i + 1][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:1][0:0])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i][j] + A[i + 1][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1213*/
+void acr1213()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1213 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[*][block], shadow[3:3][3:0]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            C[i][j] = C[i][j - 3] + C[i + 3][j] + C[i - 3][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[3:3][3:0])
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            A[i][j] = A[i][j - 3] + A[i + 3][j] + A[i - 3][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1214*/
+void acr1214()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "acr1214 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][*], shadow[3:0][3:3]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            C[i][j] = C[i - 3][j] + C[i][j + 3];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[3:0][3:3])
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            A[i][j] = A[i - 3][j] + A[i][j + 3];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------acr1215*/
+void acr1215()
+{
+    #define NL 1000
+    #define N 59
+    #define M 59
+    char tname[] = "acr1215 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[*][block], shadow[11:11][11:11]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            C[i][j] = C[i + 11][j] + C[i][j + 10] + C[i + 9][j] + C[i][j - 11] + C[i - 10][j] + C[i][j - 9];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[10:11][11:10])
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            A[i][j] = A[i + 11][j] + A[i][j + 10] + A[i + 9][j] + A[i][j - 11] + A[i - 10][j] + A[i][j - 9];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ----------------------------------------------- */
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ACROSS/acr22.cdv

@@ -0,0 +1,939 @@
+/*  ACR22
+
+    TESTING OF THE ACROSS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M) IS TO HAVE DIFFERENT
+    FLOW-DEP-LENGTH ON BOTH SIDES */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) (((a) < (b)) ? (a) : (b))
+
+static void acr2201();
+static void acr2202();
+static void acr2203();
+static void acr2204();
+static void acr2205();
+static void acr2206();
+static void acr2207();
+static void acr2208();
+static void acr2209();
+static void acr2210();
+static void acr2211();
+static void acr2212();
+static void acr2213();
+static void acr2214();
+static void acr2215();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int i, j;
+
+int main(int an, char **as)
+{
+    printf("===START OF ACR22========================\n");
+    /* ---------------------------------------- */
+    acr2201();
+    /* ---------------------------------------- */
+    acr2202();
+    /* ---------------------------------------- */
+    acr2203();
+    /* ---------------------------------------- */
+    acr2204();
+    /* ---------------------------------------- */
+    acr2205();
+    /* ---------------------------------------- */
+    acr2206();
+    /* ---------------------------------------- */
+    acr2207();
+    /* ---------------------------------------- */
+    acr2208();
+    /* ---------------------------------------- */
+    acr2209();
+    /* ---------------------------------------- */
+    acr2210();
+    /* ---------------------------------------- */
+    acr2211();
+    /* ---------------------------------------- */
+    acr2212();
+    /* ---------------------------------------- */
+    acr2213();
+    /* ---------------------------------------- */
+    acr2214();
+    /* ---------------------------------------- */
+    acr2215();
+    /* ---------------------------------------- */
+
+    printf("=== END OF ACR22 =========================\n");
+    return 0;
+}
+/* ---------------------------------------------ACR2201*/
+void acr2201()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2201 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block]
+    int (*A)[M];
+    A = (int (*)[M])malloc(N * sizeof(int[M]));
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i + 1][j] + C[i][j + 1] + C[i - 1][j] + C[i][j - 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[1:1][1:1])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i + 1][j] + A[i][j + 1] + A[i - 1][j] + A[i][j - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2202*/
+void acr2202()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2202 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i + 1][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:1][0:0])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i + 1][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2203*/
+void acr2203()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2203 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i - 1][j] + C[i][j + 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[1:0][0:1])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i - 1][j] + A[i][j + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2204*/
+void acr2204()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2204 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[1:1][0:1]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i + 1][j] + C[i][j + 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:1][0:1])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i + 1][j] + A[i][j + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi, nloopj)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2205*/
+void acr2205()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2205 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[0:1][1:1]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            C[i][j] = C[i][j - 1] + C[i + 1][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:1][1:0])
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            A[i][j] = A[i][j - 1] + A[i + 1][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2206*/
+void acr2206()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2206 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[2:2][2:2]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i + 2][j] + C[i][j + 2] + C[i + 2][j] + C[i - 2][j] + C[i][j - 2];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[2:2][2:2])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i + 2][j] + A[i][j + 2] + A[i + 2][j] + A[i - 2][j] + A[i][j - 2];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2207*/
+void acr2207()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2207 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[2:2][2:2]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i + 2][j] + C[i][j + 2] + C[i][j - 2];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:2][2:2])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i + 2][j] + A[i][j + 2] + A[i][j - 2];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2208*/
+void acr2208()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2208 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[2:2][2:2]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i - 1][j] + C[i][j - 1] + C[i - 2][j] + C[i + 2][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[2:2][2:0])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i - 1][j] + A[i][j - 1] + A[i - 2][j] + A[i + 2][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2209*/
+void acr2209()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2209 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[2:2][0:2]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i][j + 2] + C[i + 1][j] + C[i + 2][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[2:2][0:2])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i][j + 2] + A[i + 1][j] + A[i + 2][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2210*/
+void acr2210()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2210 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[3:3][3:3]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            C[i][j] = C[i + 1][j] + C[i][j + 2] + C[i + 3][j] + C[i][j -3 ] + C[i - 2][j] + C[i][j - 1];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[3:3][3:3])
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            A[i][j] = A[i + 1][j] + A[i][j + 2] + A[i + 3][j] + A[i][j - 3] + A[i - 2][j] + A[i][j - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2211*/
+void acr2211()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2211 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[3:3][0:3]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i][j] + C[i][j + 1];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:0][0:1])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i][j] + A[i][j + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2212*/
+void acr2212()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2212 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[0:3][3:3]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            C[i][j] = C[i][j] + C[i + 1][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[0:1][0:0])
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            A[i][j] = A[i][j] + A[i + 1][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2213*/
+void acr2213()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2213 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[3:3][3:0]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            C[i][j] = C[i][j - 3] + C[i + 3][j] + C[i - 3][j];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[3:3][3:0])
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            A[i][j] = A[i][j - 3] + A[i + 3][j] + A[i - 3][j];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2214*/
+void acr2214()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    char tname[] = "ACR2214 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[3:0][3:3]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            C[i][j] = C[i - 3][j] + C[i][j + 3];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[3:0][3:3])
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            A[i][j] = A[i - 3][j] + A[i][j + 3];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ---------------------------------------------ACR2215*/
+void acr2215()
+{
+    #define NL 1000
+    #define N 59
+    #define M 59
+    char tname[] = "ACR2215 ";
+    int nloopi, nloopj;
+    #pragma dvm array distribute[block][block], shadow[11:11][11:11]
+    int A[N][M];
+    int (*C)[M];
+    C = (int (*)[M])malloc(N * sizeof(int[M]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            C[i][j] = NNL + i + j;
+    nloopi = NL;
+    nloopj = NL;
+
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            C[i][j] = C[i + 11][j] + C[i][j + 10] + C[i + 9][j] + C[i][j - 11] + C[i - 10][j] + C[i][j - 9];
+
+    #pragma dvm actual(nloopi, nloopj)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) across(A[10:11][11:10])
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            A[i][j] = A[i + 11][j] + A[i][j + 10] + A[i + 9][j] + A[i][j - 11] + A[i - 10][j] + A[i][j - 9];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            if (A[i][j] != C[i][j]) {
+                nloopi = Min(nloopi, i);
+                nloopj = Min(nloopj, j);
+            }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    #undef NL
+    #undef N
+    #undef M
+}
+/* ----------------------------------------------- */
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ACROSS/acr23.cdv

@@ -0,0 +1,675 @@
+/*  ACR23
+
+    TESTING OF THE ACROSS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M,K) IS TO HAVE DIFFERENT
+    FLOW-DEP-LENGTH ON BOTH SIDES */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) (((a) < (b)) ? (a) : (b))
+
+static void acr2301();
+static void acr2302();
+static void acr2303();
+static void acr2304();
+static void acr2305();
+static void acr2306();
+static void acr2307();
+static void acr2308();
+static void acr2309();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int i, j, ii;
+
+int main(int an, char **as)
+{
+    printf("===START OF ACR23========================\n");
+    /* ---------------------------------------- */
+    acr2301();
+    /* ---------------------------------------- */
+    acr2302();
+    /* ---------------------------------------- */
+    acr2303();
+    /* ---------------------------------------- */
+    acr2304();
+    /* ---------------------------------------- */
+    acr2305();
+    /* ---------------------------------------- */
+    acr2306();
+    /* ---------------------------------------- */
+    acr2307();
+    /* ---------------------------------------- */
+    acr2308();
+    /* ---------------------------------------- */
+    acr2309();
+    /* ---------------------------------------- */
+
+    printf("=== END OF ACR23 =========================\n");
+    return 0;
+}
+/* ---------------------------------------------ACR2301*/
+void acr2301()
+{
+    #define NL 1000
+    #define N 16
+    #define M 8
+    #define K 8
+    char tname[] = "ACR2301 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[*][block][block]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                C[i][j][ii] = C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1] + C[i - 1][j][ii] + C[i][j - 1][ii] +  C[i][j][ii - 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[1:1][1:1][1:1])
+    for (ii = 1; ii < K - 1; ii++)
+        for (j = 1; j < M - 1; j++)
+            for (i = 1; i < N - 1; i++)
+                A[i][j][ii] = A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1] + A[i - 1][j][ii] + A[i][j - 1][ii] +  A[i][j][ii - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 1; ii < K - 1; ii++)
+        for (j = 1; j < M - 1; j++)
+            for (i = 1; i < N - 1; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR2302*/
+void acr2302()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    char tname[] = "ACR2302 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][*][block], shadow[2:2][2:2][2:2]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                C[i][j][ii] = C[i + 2][j][ii] + C[i][j - 2][ii] + C[i][j][ii - 1] + C[i - 1][j][ii] + C[i + 1][j][ii] + C[i][j - 1][ii] + C[i][j + 2][ii] + C[i][j][ii + 2];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[1:2][2:2][1:2])
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                A[i][j][ii] = A[i + 2][j][ii] + A[i][j - 2][ii] + A[i][j][ii - 1] + A[i - 1][j][ii] + A[i + 1][j][ii] + A[i][j - 1][ii] + A[i][j + 2][ii] + A[i][j][ii + 2];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR2303*/
+void acr2303()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    char tname[] = "ACR2303 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][*], shadow[2:2][2:2][2:2]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                C[i][j][ii] = C[i + 2][j][ii] + C[i][j + 2][ii] + C[i][j][ii + 2] + C[i][j - 2][ii] +  C[i][j - 1][ii] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[0:2][2:2][0:2])
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                A[i][j][ii] = A[i + 2][j][ii] + A[i][j + 2][ii] + A[i][j][ii + 2] + A[i][j - 2][ii] +  A[i][j - 1][ii] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR2304*/
+void acr2304()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    char tname[] = "ACR2304 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[*][block][block], shadow[2:2][2:2][2:2]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                C[i][j][ii] = C[i + 2][j][ii] + C[i][j][ii - 2] + C[i - 2][j][ii] +  C[i][j - 2][ii] + C[i - 1][j][ii] + C[i][j - 1][ii] + C[i][j][ii - 1] + C[i + 1][j][ii];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[2:2][2:0][2:0])
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                A[i][j][ii] = A[i + 2][j][ii] + A[i][j][ii - 2] + A[i - 2][j][ii] +  A[i][j - 2][ii] + A[i - 1][j][ii] + A[i][j - 1][ii] + A[i][j][ii - 1] + A[i + 1][j][ii];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR2305*/
+void acr2305()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    char tname[] = "ACR2305 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][*][block], shadow[0:2][2:2][0:2]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                C[i][j][ii] = C[i + 2][j][ii] + C[i][j + 2][ii] + C[i][j][ii + 2] + C[i][j - 2][ii] + C[i][j - 1][ii] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[0:2][2:2][0:2])
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                A[i][j][ii] = A[i + 2][j][ii] + A[i][j + 2][ii] + A[i][j][ii + 2] + A[i][j - 2][ii] + A[i][j - 1][ii] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR2306*/
+void acr2306()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    char tname[] = "ACR2306 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][*], shadow[3:3][3:3][3:3]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                C[i][j][ii] = C[i + 3][j][ii] + C[i][j + 3][ii] + C[i][j][ii + 3] + C[i - 3][j][ii] + C[i][j - 3][ii] + C[i][j][ii - 3] + C[i + 2][j][ii] + C[i][j + 2][ii] + C[i][j][ii + 2] + C[i - 2][j][ii] + C[i][j - 2][ii] + C[i][j][ii - 2] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1] + C[i - 1][j][ii] + C[i][j - 1][ii] + C[i][j][ii - 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[3:3][3:3][3:3])
+    for (ii = 3; ii < K - 3; ii++)
+        for (j = 3; j < M - 3; j++)
+            for (i = 3; i < N - 3; i++)
+                A[i][j][ii] = A[i + 3][j][ii] + A[i][j + 3][ii] + A[i][j][ii + 3] + A[i - 3][j][ii] + A[i][j - 3][ii] + A[i][j][ii - 3] + A[i + 2][j][ii] + A[i][j + 2][ii] + A[i][j][ii + 2] + A[i - 2][j][ii] + A[i][j - 2][ii] + A[i][j][ii - 2] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1] + A[i - 1][j][ii] + A[i][j - 1][ii] + A[i][j][ii - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 3; ii < K - 3; ii++)
+        for (j = 3; j < M - 3; j++)
+            for (i = 3; i < N - 3; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR2307*/
+void acr2307()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    char tname[] = "ACR2307 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[*][block][block], shadow[3:3][0:3][3:0]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                C[i][j][ii] = C[i + 3][j][ii] + C[i][j + 3][ii] + C[i - 3][j][ii] + C[i][j][ii - 3] + C[i + 2][j][ii] + C[i][j + 2][ii] + C[i - 2][j][ii] + C[i][j][ii - 2] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i - 1][j][ii] + C[i][j][ii - 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[3:3][0:3][3:0])
+    for (ii = 3; ii < K - 3; ii++)
+        for (j = 3; j < M - 3; j++)
+            for (i = 3; i < N - 3; i++)
+                A[i][j][ii] = A[i + 3][j][ii] + A[i][j + 3][ii] + A[i - 3][j][ii] + A[i][j][ii - 3] + A[i + 2][j][ii] + A[i][j + 2][ii] + A[i - 2][j][ii] + A[i][j][ii - 2] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i - 1][j][ii] + A[i][j][ii - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 3; ii < K - 3; ii++)
+        for (j = 3; j < M - 3; j++)
+            for (i = 3; i < N - 3; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR2308*/
+void acr2308()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    char tname[] = "ACR2308 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][*][block], shadow[0:3][0:3][0:3]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 0; i < N - 3; i++)
+        for (j = 0; j < M - 3; j++)
+            for (ii = 0; ii < K - 3; ii++)
+                C[i][j][ii] = C[i + 3][j][ii] + C[i][j + 3][ii] + C[i][j][ii + 3] + C[i + 2][j][ii] + C[i][j + 2][ii] + C[i][j][ii + 2] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[0:3][0:3][0:3])
+    for (ii = 0; ii < K - 3; ii++)
+        for (j = 0; j < M - 3; j++)
+            for (i = 0; i < N - 3; i++)
+                A[i][j][ii] = A[i + 3][j][ii] + A[i][j + 3][ii] + A[i][j][ii + 3] + A[i + 2][j][ii] + A[i][j + 2][ii] + A[i][j][ii + 2] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 0; ii < K - 3; ii++)
+        for (j = 0; j < M - 3; j++)
+            for (i = 0; i < N - 3; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR2309*/
+void acr2309()
+{
+    #define NL 1000
+    #define N 59
+    #define M 59
+    #define K 59
+    char tname[] = "ACR2309 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][*], shadow[11:11][11:11][11:11]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            for (ii = 11; ii < K - 11; ii++)
+                C[i][j][ii] = C[i + 11][j][ii] + C[i][j + 11][ii] + C[i][j][ii + 11] + C[i - 11][j][ii] + C[i][j - 11][ii] + C[i][j][ii - 11] + C[i + 10][j][ii] + C[i][j + 10][ii] + C[i][j][ii + 10] + C[i - 10][j][ii] + C[i][j - 10][ii] + C[i][j][ii - 10] + C[i - 9][j][ii]  + C[i][j - 9][ii]  + C[i][j][ii - 9] + C[i + 9][j][ii]  + C[i][j + 9][ii]  + C[i][j][ii + 9];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[11:11][11:11][11:11])
+    for (ii = 11; ii < K - 11; ii++)
+        for (j = 11; j < M - 11; j++)
+            for (i = 11; i < N - 11; i++)
+                A[i][j][ii] = A[i + 11][j][ii] + A[i][j + 11][ii] + A[i][j][ii + 11] + A[i - 11][j][ii] + A[i][j - 11][ii] + A[i][j][ii - 11] + A[i + 10][j][ii] + A[i][j + 10][ii] + A[i][j][ii + 10] + A[i - 10][j][ii] + A[i][j - 10][ii] + A[i][j][ii - 10] + A[i - 9][j][ii]  + A[i][j - 9][ii]  + A[i][j][ii - 9] + A[i + 9][j][ii]  + A[i][j + 9][ii]  + A[i][j][ii + 9];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 11; ii < K - 11; ii++)
+        for (j = 11; j < M - 11; j++)
+            for (i = 11; i < N - 11; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ----------------------------------------------- */
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ACROSS/acr33.cdv

@@ -0,0 +1,675 @@
+/*  ACR33
+
+    TESTING OF THE ACROSS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M,K) IS TO HAVE DIFFERENT
+    FLOW-DEP-LENGTH ON BOTH SIDES */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) (((a) < (b)) ? (a) : (b))
+
+static void acr3301();
+static void acr3302();
+static void acr3303();
+static void acr3304();
+static void acr3305();
+static void acr3306();
+static void acr3307();
+static void acr3308();
+static void acr3309();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int i, j, ii;
+
+int main(int an, char **as)
+{
+    printf("===START OF ACR33========================\n");
+    /* ---------------------------------------- */
+    acr3301();
+    /* ---------------------------------------- */
+    acr3302();
+    /* ---------------------------------------- */
+    acr3303();
+    /* ---------------------------------------- */
+    acr3304();
+    /* ---------------------------------------- */
+    acr3305();
+    /* ---------------------------------------- */
+    acr3306();
+    /* ---------------------------------------- */
+    acr3307();
+    /* ---------------------------------------- */
+    acr3308();
+    /* ---------------------------------------- */
+    acr3309();
+    /* ---------------------------------------- */
+
+    printf("=== END OF ACR33 =========================\n");
+    return 0;
+}
+/* ---------------------------------------------ACR3301*/
+void acr3301()
+{
+    #define NL 1000
+    #define N 16
+    #define M 8
+    #define K 8
+    char tname[] = "ACR3301 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][block]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                C[i][j][ii] = C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1] + C[i - 1][j][ii] + C[i][j - 1][ii] +  C[i][j][ii - 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[1:1][1:1][1:1])
+    for (ii = 1; ii < K - 1; ii++)
+        for (j = 1; j < M - 1; j++)
+            for (i = 1; i < N - 1; i++)
+                A[i][j][ii] = A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1] + A[i - 1][j][ii] + A[i][j - 1][ii] +  A[i][j][ii - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 1; ii < K - 1; ii++)
+        for (j = 1; j < M - 1; j++)
+            for (i = 1; i < N - 1; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR3302*/
+void acr3302()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    char tname[] = "ACR3302 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][block], shadow[2:2][2:2][2:2]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                C[i][j][ii] = C[i + 2][j][ii] + C[i][j - 2][ii] + C[i][j][ii - 1] + C[i - 1][j][ii] + C[i + 1][j][ii] + C[i][j - 1][ii] + C[i][j + 2][ii] + C[i][j][ii + 2];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[1:2][2:2][1:2])
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                A[i][j][ii] = A[i + 2][j][ii] + A[i][j - 2][ii] + A[i][j][ii - 1] + A[i - 1][j][ii] + A[i + 1][j][ii] + A[i][j - 1][ii] + A[i][j + 2][ii] + A[i][j][ii + 2];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR3303*/
+void acr3303()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    char tname[] = "ACR3303 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][block], shadow[2:2][2:2][2:2]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                C[i][j][ii] = C[i + 2][j][ii] + C[i][j + 2][ii] + C[i][j][ii + 2] + C[i][j - 2][ii] +  C[i][j - 1][ii] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[0:2][2:2][0:2])
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                A[i][j][ii] = A[i + 2][j][ii] + A[i][j + 2][ii] + A[i][j][ii + 2] + A[i][j - 2][ii] +  A[i][j - 1][ii] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR3304*/
+void acr3304()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    char tname[] = "ACR3304 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][block], shadow[2:2][2:2][2:2]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                C[i][j][ii] = C[i + 2][j][ii] + C[i][j][ii - 2] + C[i - 2][j][ii] +  C[i][j - 2][ii] + C[i - 1][j][ii] + C[i][j - 1][ii] + C[i][j][ii - 1] + C[i + 1][j][ii];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[2:2][2:0][2:0])
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                A[i][j][ii] = A[i + 2][j][ii] + A[i][j][ii - 2] + A[i - 2][j][ii] +  A[i][j - 2][ii] + A[i - 1][j][ii] + A[i][j - 1][ii] + A[i][j][ii - 1] + A[i + 1][j][ii];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR3305*/
+void acr3305()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    char tname[] = "ACR3305 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][block], shadow[0:2][2:2][0:2]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                C[i][j][ii] = C[i + 2][j][ii] + C[i][j + 2][ii] + C[i][j][ii + 2] + C[i][j - 2][ii] + C[i][j - 1][ii] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[0:2][2:2][0:2])
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                A[i][j][ii] = A[i + 2][j][ii] + A[i][j + 2][ii] + A[i][j][ii + 2] + A[i][j - 2][ii] + A[i][j - 1][ii] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 2; ii < K - 2; ii++)
+        for (j = 2; j < M - 2; j++)
+            for (i = 2; i < N - 2; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR3306*/
+void acr3306()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    char tname[] = "ACR3306 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][block], shadow[3:3][3:3][3:3]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                C[i][j][ii] = C[i + 3][j][ii] + C[i][j + 3][ii] + C[i][j][ii + 3] + C[i - 3][j][ii] + C[i][j - 3][ii] + C[i][j][ii - 3] + C[i + 2][j][ii] + C[i][j + 2][ii] + C[i][j][ii + 2] + C[i - 2][j][ii] + C[i][j - 2][ii] + C[i][j][ii - 2] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1] + C[i - 1][j][ii] + C[i][j - 1][ii] + C[i][j][ii - 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[3:3][3:3][3:3])
+    for (ii = 3; ii < K - 3; ii++)
+        for (j = 3; j < M - 3; j++)
+            for (i = 3; i < N - 3; i++)
+                A[i][j][ii] = A[i + 3][j][ii] + A[i][j + 3][ii] + A[i][j][ii + 3] + A[i - 3][j][ii] + A[i][j - 3][ii] + A[i][j][ii - 3] + A[i + 2][j][ii] + A[i][j + 2][ii] + A[i][j][ii + 2] + A[i - 2][j][ii] + A[i][j - 2][ii] + A[i][j][ii - 2] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1] + A[i - 1][j][ii] + A[i][j - 1][ii] + A[i][j][ii - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 3; ii < K - 3; ii++)
+        for (j = 3; j < M - 3; j++)
+            for (i = 3; i < N - 3; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR3307*/
+void acr3307()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    char tname[] = "ACR3307 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][block], shadow[3:3][0:3][3:0]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                C[i][j][ii] = C[i + 3][j][ii] + C[i][j + 3][ii] + C[i - 3][j][ii] + C[i][j][ii - 3] + C[i + 2][j][ii] + C[i][j + 2][ii] + C[i - 2][j][ii] + C[i][j][ii - 2] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i - 1][j][ii] + C[i][j][ii - 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[3:3][0:3][3:0])
+    for (ii = 3; ii < K - 3; ii++)
+        for (j = 3; j < M - 3; j++)
+            for (i = 3; i < N - 3; i++)
+                A[i][j][ii] = A[i + 3][j][ii] + A[i][j + 3][ii] + A[i - 3][j][ii] + A[i][j][ii - 3] + A[i + 2][j][ii] + A[i][j + 2][ii] + A[i - 2][j][ii] + A[i][j][ii - 2] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i - 1][j][ii] + A[i][j][ii - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 3; ii < K - 3; ii++)
+        for (j = 3; j < M - 3; j++)
+            for (i = 3; i < N - 3; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR3308*/
+void acr3308()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    char tname[] = "ACR3308 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][block], shadow[0:3][0:3][0:3]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 0; i < N - 3; i++)
+        for (j = 0; j < M - 3; j++)
+            for (ii = 0; ii < K - 3; ii++)
+                C[i][j][ii] = C[i + 3][j][ii] + C[i][j + 3][ii] + C[i][j][ii + 3] + C[i + 2][j][ii] + C[i][j + 2][ii] + C[i][j][ii + 2] + C[i + 1][j][ii] + C[i][j + 1][ii] + C[i][j][ii + 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[0:3][0:3][0:3])
+    for (ii = 0; ii < K - 3; ii++)
+        for (j = 0; j < M - 3; j++)
+            for (i = 0; i < N - 3; i++)
+                A[i][j][ii] = A[i + 3][j][ii] + A[i][j + 3][ii] + A[i][j][ii + 3] + A[i + 2][j][ii] + A[i][j + 2][ii] + A[i][j][ii + 2] + A[i + 1][j][ii] + A[i][j + 1][ii] + A[i][j][ii + 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 0; ii < K - 3; ii++)
+        for (j = 0; j < M - 3; j++)
+            for (i = 0; i < N - 3; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ---------------------------------------------ACR3309*/
+void acr3309()
+{
+    #define NL 1000
+    #define N 59
+    #define M 59
+    #define K 59
+    char tname[] = "ACR3309 ";
+    int nloopi, nloopj, nloopii;
+    #pragma dvm array distribute[block][block][block], shadow[11:11][11:11][11:11]
+    int (*A)[M][K];
+    A = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int (*C)[M][K];
+    C = (int (*)[M][K])malloc(N * sizeof(int[M][K]));
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                C[i][j][ii] = NNL + i + j + ii;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            for (ii = 11; ii < K - 11; ii++)
+                C[i][j][ii] = C[i + 11][j][ii] + C[i][j + 11][ii] + C[i][j][ii + 11] + C[i - 11][j][ii] + C[i][j - 11][ii] + C[i][j][ii - 11] + C[i + 10][j][ii] + C[i][j + 10][ii] + C[i][j][ii + 10] + C[i - 10][j][ii] + C[i][j - 10][ii] + C[i][j][ii - 10] + C[i - 9][j][ii]  + C[i][j - 9][ii]  + C[i][j][ii - 9] + C[i + 9][j][ii]  + C[i][j + 9][ii]  + C[i][j][ii + 9];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii])
+    for (ii = 0; ii < K; ii++)
+        for (j = 0; j < M; j++)
+            for (i = 0; i < N; i++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) across(A[11:11][11:11][11:11])
+    for (ii = 11; ii < K - 11; ii++)
+        for (j = 11; j < M - 11; j++)
+            for (i = 11; i < N - 11; i++)
+                A[i][j][ii] = A[i + 11][j][ii] + A[i][j + 11][ii] + A[i][j][ii + 11] + A[i - 11][j][ii] + A[i][j - 11][ii] + A[i][j][ii - 11] + A[i + 10][j][ii] + A[i][j + 10][ii] + A[i][j][ii + 10] + A[i - 10][j][ii] + A[i][j - 10][ii] + A[i][j][ii - 10] + A[i - 9][j][ii]  + A[i][j - 9][ii]  + A[i][j][ii - 9] + A[i + 9][j][ii]  + A[i][j + 9][ii]  + A[i][j][ii + 9];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([ii][j][i] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (ii = 11; ii < K - 11; ii++)
+        for (j = 11; j < M - 11; j++)
+            for (i = 11; i < N - 11; i++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    nloopi = Min(nloopi, i);
+                    nloopj = Min(nloopj, j);
+                    nloopii = Min(nloopii, ii);
+                }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+}
+/* ----------------------------------------------- */
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ACROSS/acr34.cdv

@@ -0,0 +1,723 @@
+/*  ACR34
+
+    TESTING OF THE ACROSS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M,K,L) IS TO HAVE DIFFERENT
+    FLOW-DEP-LENGTH ON BOTH SIDES */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) (((a) < (b)) ? (a) : (b))
+
+static void acr3401();
+static void acr3402();
+static void acr3403();
+static void acr3404();
+static void acr3405();
+static void acr3406();
+static void acr3407();
+static void acr3408();
+static void acr3409();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int i, j, ii, jj;
+
+int main(int an, char **as)
+{
+    printf("===START OF ACR34========================\n");
+    /* ---------------------------------------- */
+    acr3401();
+    /* ---------------------------------------- */
+    acr3402();
+    /* ---------------------------------------- */
+    acr3403();
+    /* ---------------------------------------- */
+    acr3404();
+    /* ---------------------------------------- */
+    acr3405();
+    /* ---------------------------------------- */
+    acr3406();
+    /* ---------------------------------------- */
+    acr3407();
+    /* ---------------------------------------- */
+    acr3408();
+    /* ---------------------------------------- */
+    acr3409();
+    /* ---------------------------------------- */
+
+    printf("=== END OF ACR34 =========================\n");
+    return 0;
+}
+/* ---------------------------------------------ACR3401*/
+void acr3401()
+{
+    #define NL 1000
+    #define N 16
+    #define M 8
+    #define K 8
+    #define L 8
+    char tname[] = "ACR3401 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[*][block][block][block]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+    printf("1234r5\n");
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    C[i][j][ii][jj] = C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 1] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii - 1][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[1:1][1:1][1:1][1:1])
+    for (jj = 1; jj < L - 1; jj++)
+        for (ii = 1; ii < K - 1; ii++)
+            for (j = 1; j < M - 1; j++)
+                for (i = 1; i < N - 1; i++)
+                    A[i][j][ii][jj] = A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 1] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii - 1][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 1; jj < L - 1; jj++)
+        for (ii = 1; ii < K - 1; ii++)
+            for (j = 1; j < M - 1; j++)
+                for (i = 1; i < N - 1; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR3402*/
+void acr3402()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    #define L 10
+    char tname[] = "ACR3402 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[*][block][block][block], shadow[2:2][2:2][2:2][2:2]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    C[i][j][ii][jj] = C[i + 2][j][ii][jj] + C[i][j + 2][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 2] + C[i - 1][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii - 2][jj] + C[i][j][ii][jj - 1] + C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii][jj + 1] + C[i][j - 1][ii][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[1:2][2:2][2:1][1:2])
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    A[i][j][ii][jj] = A[i + 2][j][ii][jj] + A[i][j + 2][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 2] + A[i - 1][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii - 2][jj] + A[i][j][ii][jj - 1] + A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii][jj + 1] + A[i][j - 1][ii][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR3403*/
+void acr3403()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    #define L 10
+    char tname[] = "ACR3403 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[*][block][block][block], shadow[2:2][2:2][2:2][2:2]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    C[i][j][ii][jj] = C[i - 2][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii - 2][jj] + C[i][j][ii][jj - 2] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii - 1][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[2:0][2:2][2:0][2:0])
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    A[i][j][ii][jj] = A[i - 2][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii - 2][jj] + A[i][j][ii][jj - 2] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii - 1][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR3404*/
+void acr3404()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    #define L 10
+    char tname[] = "ACR3404 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[*][block][block][block], shadow[2:2][2:2][2:2][2:2]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    C[i][j][ii][jj] = C[i + 2][j][ii][jj] + C[i][j][ii][jj + 2] + C[i - 2][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii - 2][jj] + C[i + 1][j][ii][jj] + C[i][j][ii][jj + 1] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii - 1][jj];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[2:2][2:0][2:0][0:2])
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    A[i][j][ii][jj] = A[i + 2][j][ii][jj] + A[i][j][ii][jj + 2] + A[i - 2][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii - 2][jj] + A[i + 1][j][ii][jj] + A[i][j][ii][jj + 1] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii - 1][jj];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR3405*/
+void acr3405()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+    char tname[] = "ACR3405 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[*][block][block][block], shadow[2:2][2:0][0:2][2:2]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    C[i][j][ii][jj] = C[i + 2][j][ii][jj] + C[i][j][ii + 2][jj] + C[i][j][ii][jj + 2] + C[i - 2][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii][jj - 2] + C[i + 1][j][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 1] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region inout(C)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[2:2][2:0][0:2][2:2])
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    A[i][j][ii][jj] = A[i + 2][j][ii][jj] + A[i][j][ii + 2][jj] + A[i][j][ii][jj + 2] + A[i - 2][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii][jj - 2] + A[i + 1][j][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 1] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR3406*/
+void acr3406()
+{
+    #define NL 1000
+    #define N 32
+    #define M 16
+    #define K 16
+    #define L 16
+    char tname[] = "ACR3406 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[*][block][block][block], shadow[3:3][3:3][3:3][3:3]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    C[i][j][ii][jj] = C[i + 3][j][ii][jj] + C[i][j + 3][ii][jj] + C[i][j][ii + 3][jj] + C[i][j][ii][jj + 3] + C[i - 3][j][ii][jj] + C[i][j - 3][ii][jj] + C[i][j][ii - 3][jj] + C[i][j][ii][jj - 3] + C[i + 2][j][ii][jj] + C[i][j + 2][ii][jj] + C[i][j][ii + 2][jj] + C[i][j][ii][jj + 2] + C[i - 2][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii - 2][jj] + C[i][j][ii][jj - 2] + C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 1] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii - 1][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[3:3][3:3][3:3][3:3])
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    A[i][j][ii][jj] = A[i + 3][j][ii][jj] + A[i][j + 3][ii][jj] + A[i][j][ii + 3][jj] + A[i][j][ii][jj + 3] + A[i - 3][j][ii][jj] + A[i][j - 3][ii][jj] + A[i][j][ii - 3][jj] + A[i][j][ii][jj - 3] + A[i + 2][j][ii][jj] + A[i][j + 2][ii][jj] + A[i][j][ii + 2][jj] + A[i][j][ii][jj + 2] + A[i - 2][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii - 2][jj] + A[i][j][ii][jj - 2] + A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 1] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii - 1][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR3407*/
+void acr3407()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+    char tname[] = "ACR3407 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[*][block][block][block], shadow[0:3][3:3][0:3][0:3]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    C[i][j][ii][jj] = C[i + 3][j][ii][jj] + C[i][j + 3][ii][jj] + C[i][j][ii + 3][jj] + C[i][j][ii][jj + 3] + C[i][j - 3][ii][jj] + C[i + 2][j][ii][jj] + C[i][j + 2][ii][jj] + C[i][j][ii + 2][jj] + C[i][j][ii][jj + 2] + C[i][j - 2][ii][jj] + C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 1] + C[i][j - 1][ii][jj];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[0:3][3:3][0:3][0:3])
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    A[i][j][ii][jj] = A[i + 3][j][ii][jj] + A[i][j + 3][ii][jj] + A[i][j][ii + 3][jj] + A[i][j][ii][jj + 3] + A[i][j - 3][ii][jj] + A[i + 2][j][ii][jj] + A[i][j + 2][ii][jj] + A[i][j][ii + 2][jj] + A[i][j][ii][jj + 2] + A[i][j - 2][ii][jj] + A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 1] + A[i][j - 1][ii][jj];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR3408*/
+void acr3408()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+    char tname[] = "ACR3408 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[*][block][block][block], shadow[0:3][3:3][0:3][3:0]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    C[i][j][ii][jj] = C[i + 3][j][ii][jj] + C[i][j + 3][ii][jj] + C[i][j][ii + 3][jj] + C[i][j][ii][jj - 3] + C[i + 2][j][ii][jj] + C[i][j + 2][ii][jj] + C[i][j][ii + 2][jj] + C[i][j][ii][jj - 2] + C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[0:3][0:3][0:3][3:0])
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    A[i][j][ii][jj] = A[i + 3][j][ii][jj] + A[i][j + 3][ii][jj] + A[i][j][ii + 3][jj] + A[i][j][ii][jj - 3] + A[i + 2][j][ii][jj] + A[i][j + 2][ii][jj] + A[i][j][ii + 2][jj] + A[i][j][ii][jj - 2] + A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR3409*/
+void acr3409()
+{
+    #define NL 1000
+    #define N 59
+    #define M 59
+    #define K 59
+    #define L 59
+    char tname[] = "ACR3409 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[*][block][block][block], shadow[11:11][11:11][11:11][11:11]
+    int (*A)[M][K][L];
+    int (*C)[M][K][L];
+    int NNL = NL;
+    A = malloc(N * M * K * L * sizeof(int));
+    C = malloc(N * M * K * L * sizeof(int));
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            for (ii = 11; ii < K - 11; ii++)
+                for (jj = 11; jj < L - 11; jj++)
+                    C[i][j][ii][jj] = C[i + 11][j][ii][jj] + C[i][j + 11][ii][jj] + C[i][j][ii + 11][jj] + C[i][j][ii][jj + 11] + C[i - 11][j][ii][jj] + C[i][j - 11][ii][jj] + C[i][j][ii - 11][jj] + C[i][j][ii][jj - 11];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[11:11][11:11][11:11][11:11])
+    for (jj = 11; jj < L - 11; jj++)
+        for (ii = 11; ii < K - 11; ii++)
+            for (j = 11; j < M - 11; j++)
+                for (i = 11; i < N - 11; i++)
+                    A[i][j][ii][jj] = A[i + 11][j][ii][jj] + A[i][j + 11][ii][jj] + A[i][j][ii + 11][jj] + A[i][j][ii][jj + 11] + A[i - 11][j][ii][jj] + A[i][j - 11][ii][jj] + A[i][j][ii - 11][jj] + A[i][j][ii][jj - 11];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 11; jj < L - 11; jj++)
+        for (ii = 11; ii < K - 11; ii++)
+            for (j = 11; j < M - 11; j++)
+                for (i = 11; i < N - 11; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ----------------------------------------------- */
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ACROSS/acr44.cdv

@@ -0,0 +1,723 @@
+/*  ACR44
+
+    TESTING OF THE ACROSS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M,K,L) IS TO HAVE DIFFERENT
+    FLOW-DEP-LENGTH ON BOTH SIDES */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) (((a) < (b)) ? (a) : (b))
+
+static void acr4401();
+static void acr4402();
+static void acr4403();
+static void acr4404();
+static void acr4405();
+static void acr4406();
+static void acr4407();
+static void acr4408();
+static void acr4409();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int i, j, ii, jj;
+
+int main(int an, char **as)
+{
+    printf("===START OF ACR44========================\n");
+    /* ---------------------------------------- */
+    acr4401();
+    /* ---------------------------------------- */
+    acr4402();
+    /* ---------------------------------------- */
+    acr4403();
+    /* ---------------------------------------- */
+    acr4404();
+    /* ---------------------------------------- */
+    acr4405();
+    /* ---------------------------------------- */
+    acr4406();
+    /* ---------------------------------------- */
+    acr4407();
+    /* ---------------------------------------- */
+    acr4408();
+    /* ---------------------------------------- */
+    acr4409();
+    /* ---------------------------------------- */
+
+    printf("=== END OF ACR44 =========================\n");
+    return 0;
+}
+/* ---------------------------------------------ACR4401*/
+void acr4401()
+{
+    #define NL 1000
+    #define N 16
+    #define M 8
+    #define K 8
+    #define L 8
+    char tname[] = "ACR4401 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+    printf("1234r5\n");
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    C[i][j][ii][jj] = C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 1] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii - 1][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[1:1][1:1][1:1][1:1])
+    for (jj = 1; jj < L - 1; jj++)
+        for (ii = 1; ii < K - 1; ii++)
+            for (j = 1; j < M - 1; j++)
+                for (i = 1; i < N - 1; i++)
+                    A[i][j][ii][jj] = A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 1] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii - 1][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 1; jj < L - 1; jj++)
+        for (ii = 1; ii < K - 1; ii++)
+            for (j = 1; j < M - 1; j++)
+                for (i = 1; i < N - 1; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR4402*/
+void acr4402()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    #define L 10
+    char tname[] = "ACR4402 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[block][block][block][block], shadow[2:2][2:2][2:2][2:2]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    C[i][j][ii][jj] = C[i + 2][j][ii][jj] + C[i][j + 2][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 2] + C[i - 1][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii - 2][jj] + C[i][j][ii][jj - 1] + C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii][jj + 1] + C[i][j - 1][ii][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[1:2][2:2][2:1][1:2])
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    A[i][j][ii][jj] = A[i + 2][j][ii][jj] + A[i][j + 2][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 2] + A[i - 1][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii - 2][jj] + A[i][j][ii][jj - 1] + A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii][jj + 1] + A[i][j - 1][ii][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR4403*/
+void acr4403()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    #define L 10
+    char tname[] = "ACR4403 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[block][block][block][block], shadow[2:2][2:2][2:2][2:2]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    C[i][j][ii][jj] = C[i - 2][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii - 2][jj] + C[i][j][ii][jj - 2] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii - 1][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, nloopj, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[2:0][2:2][2:0][2:0])
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    A[i][j][ii][jj] = A[i - 2][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii - 2][jj] + A[i][j][ii][jj - 2] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii - 1][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR4404*/
+void acr4404()
+{
+    #define NL 1000
+    #define N 16
+    #define M 10
+    #define K 10
+    #define L 10
+    char tname[] = "ACR4404 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[block][block][block][block], shadow[2:2][2:2][2:2][2:2]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    C[i][j][ii][jj] = C[i + 2][j][ii][jj] + C[i][j][ii][jj + 2] + C[i - 2][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii - 2][jj] + C[i + 1][j][ii][jj] + C[i][j][ii][jj + 1] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii - 1][jj];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[2:2][2:0][2:0][0:2])
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    A[i][j][ii][jj] = A[i + 2][j][ii][jj] + A[i][j][ii][jj + 2] + A[i - 2][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii - 2][jj] + A[i + 1][j][ii][jj] + A[i][j][ii][jj + 1] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii - 1][jj];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR4405*/
+void acr4405()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+    char tname[] = "ACR4405 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[block][block][block][block], shadow[2:2][2:0][0:2][2:2]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    C[i][j][ii][jj] = C[i + 2][j][ii][jj] + C[i][j][ii + 2][jj] + C[i][j][ii][jj + 2] + C[i - 2][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii][jj - 2] + C[i + 1][j][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 1] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region inout(C)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[2:2][2:0][0:2][2:2])
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    A[i][j][ii][jj] = A[i + 2][j][ii][jj] + A[i][j][ii + 2][jj] + A[i][j][ii][jj + 2] + A[i - 2][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii][jj - 2] + A[i + 1][j][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 1] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 2; jj < L - 2; jj++)
+        for (ii = 2; ii < K - 2; ii++)
+            for (j = 2; j < M - 2; j++)
+                for (i = 2; i < N - 2; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR4406*/
+void acr4406()
+{
+    #define NL 1000
+    #define N 32
+    #define M 16
+    #define K 16
+    #define L 16
+    char tname[] = "ACR4406 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[block][block][block][block], shadow[3:3][3:3][3:3][3:3]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    C[i][j][ii][jj] = C[i + 3][j][ii][jj] + C[i][j + 3][ii][jj] + C[i][j][ii + 3][jj] + C[i][j][ii][jj + 3] + C[i - 3][j][ii][jj] + C[i][j - 3][ii][jj] + C[i][j][ii - 3][jj] + C[i][j][ii][jj - 3] + C[i + 2][j][ii][jj] + C[i][j + 2][ii][jj] + C[i][j][ii + 2][jj] + C[i][j][ii][jj + 2] + C[i - 2][j][ii][jj] + C[i][j - 2][ii][jj] + C[i][j][ii - 2][jj] + C[i][j][ii][jj - 2] + C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 1] + C[i - 1][j][ii][jj] + C[i][j - 1][ii][jj] + C[i][j][ii - 1][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[3:3][3:3][3:3][3:3])
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    A[i][j][ii][jj] = A[i + 3][j][ii][jj] + A[i][j + 3][ii][jj] + A[i][j][ii + 3][jj] + A[i][j][ii][jj + 3] + A[i - 3][j][ii][jj] + A[i][j - 3][ii][jj] + A[i][j][ii - 3][jj] + A[i][j][ii][jj - 3] + A[i + 2][j][ii][jj] + A[i][j + 2][ii][jj] + A[i][j][ii + 2][jj] + A[i][j][ii][jj + 2] + A[i - 2][j][ii][jj] + A[i][j - 2][ii][jj] + A[i][j][ii - 2][jj] + A[i][j][ii][jj - 2] + A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 1] + A[i - 1][j][ii][jj] + A[i][j - 1][ii][jj] + A[i][j][ii - 1][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR4407*/
+void acr4407()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+    char tname[] = "ACR4407 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[block][block][block][block], shadow[0:3][3:3][0:3][0:3]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    C[i][j][ii][jj] = C[i + 3][j][ii][jj] + C[i][j + 3][ii][jj] + C[i][j][ii + 3][jj] + C[i][j][ii][jj + 3] + C[i][j - 3][ii][jj] + C[i + 2][j][ii][jj] + C[i][j + 2][ii][jj] + C[i][j][ii + 2][jj] + C[i][j][ii][jj + 2] + C[i][j - 2][ii][jj] + C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj + 1] + C[i][j - 1][ii][jj];
+
+    #pragma dvm actual(nloopi)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[0:3][3:3][0:3][0:3])
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    A[i][j][ii][jj] = A[i + 3][j][ii][jj] + A[i][j + 3][ii][jj] + A[i][j][ii + 3][jj] + A[i][j][ii][jj + 3] + A[i][j - 3][ii][jj] + A[i + 2][j][ii][jj] + A[i][j + 2][ii][jj] + A[i][j][ii + 2][jj] + A[i][j][ii][jj + 2] + A[i][j - 2][ii][jj] + A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj + 1] + A[i][j - 1][ii][jj];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR4408*/
+void acr4408()
+{
+    #define NL 1000
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+    char tname[] = "ACR4408 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[block][block][block][block], shadow[0:3][3:3][0:3][3:0]
+    int A[N][M][K][L];
+    int C[N][M][K][L];
+    int NNL = NL;
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    C[i][j][ii][jj] = C[i + 3][j][ii][jj] + C[i][j + 3][ii][jj] + C[i][j][ii + 3][jj] + C[i][j][ii][jj - 3] + C[i + 2][j][ii][jj] + C[i][j + 2][ii][jj] + C[i][j][ii + 2][jj] + C[i][j][ii][jj - 2] + C[i + 1][j][ii][jj] + C[i][j + 1][ii][jj] + C[i][j][ii + 1][jj] + C[i][j][ii][jj - 1];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region inout(C), out(A)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[0:3][0:3][0:3][3:0])
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    A[i][j][ii][jj] = A[i + 3][j][ii][jj] + A[i][j + 3][ii][jj] + A[i][j][ii + 3][jj] + A[i][j][ii][jj - 3] + A[i + 2][j][ii][jj] + A[i][j + 2][ii][jj] + A[i][j][ii + 2][jj] + A[i][j][ii][jj - 2] + A[i + 1][j][ii][jj] + A[i][j + 1][ii][jj] + A[i][j][ii + 1][jj] + A[i][j][ii][jj - 1];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 3; jj < L - 3; jj++)
+        for (ii = 3; ii < K - 3; ii++)
+            for (j = 3; j < M - 3; j++)
+                for (i = 3; i < N - 3; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------ACR4409*/
+void acr4409()
+{
+    #define NL 1000
+    #define N 59
+    #define M 59
+    #define K 59
+    #define L 59
+    char tname[] = "ACR4409 ";
+    int nloopi, nloopj, nloopii, nloopjj;
+    #pragma dvm array distribute[block][block][block][block], shadow[11:11][11:11][11:11][11:11]
+    int (*A)[M][K][L];
+    int (*C)[M][K][L];
+    int NNL = NL;
+    A = malloc(N * M * K * L * sizeof(int));
+    C = malloc(N * M * K * L * sizeof(int));
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NNL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    for (i = 11; i < N - 11; i++)
+        for (j = 11; j < M - 11; j++)
+            for (ii = 11; ii < K - 11; ii++)
+                for (jj = 11; jj < L - 11; jj++)
+                    C[i][j][ii][jj] = C[i + 11][j][ii][jj] + C[i][j + 11][ii][jj] + C[i][j][ii + 11][jj] + C[i][j][ii][jj + 11] + C[i - 11][j][ii][jj] + C[i][j - 11][ii][jj] + C[i][j][ii - 11][jj] + C[i][j][ii][jj - 11];
+
+    #pragma dvm actual(nloopi, C)
+    #pragma dvm region in(C)
+    {
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj])
+    for (jj = 0; jj < L; jj++)
+        for (ii = 0; ii < K; ii++)
+            for (j = 0; j < M; j++)
+                for (i = 0; i < N; i++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) across(A[11:11][11:11][11:11][11:11])
+    for (jj = 11; jj < L - 11; jj++)
+        for (ii = 11; ii < K - 11; ii++)
+            for (j = 11; j < M - 11; j++)
+                for (i = 11; i < N - 11; i++)
+                    A[i][j][ii][jj] = A[i + 11][j][ii][jj] + A[i][j + 11][ii][jj] + A[i][j][ii + 11][jj] + A[i][j][ii][jj + 11] + A[i - 11][j][ii][jj] + A[i][j - 11][ii][jj] + A[i][j][ii - 11][jj] + A[i][j][ii][jj - 11];
+    }
+    #pragma dvm get_actual(A)
+    #pragma dvm parallel([jj][ii][j][i] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (jj = 11; jj < L - 11; jj++)
+        for (ii = 11; ii < K - 11; ii++)
+            for (j = 11; j < M - 11; j++)
+                for (i = 11; i < N - 11; i++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        nloopi = Min(nloopi, i);
+                        nloopj = Min(nloopj, j);
+                        nloopii = Min(nloopii, ii);
+                        nloopjj = Min(nloopjj, jj);
+                    }
+
+    #pragma dvm get_actual(nloopi)
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(C);
+    free(A);
+    #undef NL
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ----------------------------------------------- */
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ACROSS/settings

@@ -0,0 +1 @@
+ALLOW_MULTIDEV=0

dvm/tools/tester/trunk/test-suite/Correctness/C/ALIGN/align11.cdv

@@ -0,0 +1,415 @@
+/*    ALIGN11
+TESTING align CLAUSE */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void align111();
+static void align1111();
+static void align1112();
+static void align112();
+static void align113();
+static void align114();
+static void align115();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF ALIGN11 ======================\n");
+        /* ALIGN arrB[i] WITH arrA[i] normal*/
+    align111();
+        /* ALIGN arrB[i] WITH arrA[i] small array*/
+    align1111();
+        /* ALIGN arrB[i] WITH arrA[2 * i+3] small array*/
+    align1112();
+        /* ALIGN arrB[i] WITH arrA[i + 4] shift along i*/
+    align112();
+        /* ALIGN arrB[i] WITH arrA[-i + 7] reverse on i*/
+//    align113();
+        /* ALIGN arrB[i] WITH arrA[2 * i + 8] stretching along i*/
+    align114();
+        /* ALIGN arrB[] WITH arrA[]*/
+    align115();
+
+    printf("=== END OF ALIGN11 ========================\n");
+    return 0;
+}
+/* ---------------------------------------------ALIGN111*/
+/* ALIGN arrB[i] WITH arrA[i] normal*/
+void align111()
+{
+/*    parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    #define AN1 8
+    #define BN1 8
+    int k1i = 1;
+    int li = 0;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+    char tname[] = "align111 ";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN1111*/
+/* ALIGN arrB[i] WITH arrA[i] small array*/
+void align1111()
+{
+/*    parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    #define AN1 5
+    #define BN1 2
+    int k1i = 1;
+    int li = 0;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+    char tname[] = "align1111";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN1112*/
+/* ALIGN arrB[i] WITH arrA[2 * i + 1] small array*/
+void align1112()
+{
+/*    parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    #define AN1 5
+    #define BN1 2
+    int k1i = 2;
+    int li  = 1;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+    char tname[] = "align1112";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN112*/
+/* ALIGN arrB[i] WITH arrA[i + 4] shift along i*/
+void align112()
+{
+/*    parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    #define AN1 8
+    #define BN1 4
+    int k1i = 1;
+    int li  = 4;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+    char tname[] = "align112 ";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN113*/
+/* ALIGN arrB[i] WITH arrA[-i + 7] reverse on i*/
+void align113()
+{
+/*    parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    #define AN1 8
+    #define BN1 8
+    int k1i = -1;
+    int li = 7;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+    char tname[] = "align113 ";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN114*/
+/* ALIGN arrB[i] WITH arrA[2 * i + 8] stretching along i*/
+void align114()
+{
+/*    parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    #define AN1 24
+    #define BN1 8
+    int k1i = 2;
+    int li  = 8;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+    char tname[] = "align114 ";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A1, B1), inout(erri)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN115*/
+/* ALIGN arrB[] WITH arrA[]*/
+void align115()
+{
+/*    parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    #define AN1 24
+    #define BN1 8
+    int k1i = 0;
+    int li  = 0;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([] with A1[])
+    int B1[BN1];
+    char tname[] = "align115 ";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = i;
+    #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), private(j)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < BN1; j++)
+            if (B1[j] != (j))
+                if (erri > j) erri = j;
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef BN1
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ALIGN/align12.cdv

@@ -0,0 +1,228 @@
+/*    ALIGN12
+TESTING align CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void align121();
+static void align122();
+static void align123();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+static int s, cs, erri, i, j, ia, ja, ib, jb;
+
+int main(int an, char **as)
+{
+    printf("=== START OF ALIGN12 ======================\n");
+/* ALIGN arrB[][i] WITH arrA[i]*/
+    align121();
+/*  ALIGN arrB[i][] WITH arrA[2 * i + 1]*/
+    align122();
+/*  ALIGN arrB[][] WITH arrA[]*/
+    align123();
+
+    printf("=== END OF ALIGN12 ========================\n");
+    return 0;
+}
+/* ---------------------------------------------ALIGN121*/
+/* ALIGN arrB[][i] WITH arrA[i]*/
+void align121()
+{
+/*     parameters for ALIGN arrB[][i] WITH arrA[k1i * i + li]*/
+    #define AN1 8
+    #define AN2 0
+    #define BN1 4
+    #define BN2 4
+    int k1i = 1;
+    int li = 0;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([][i] with A1[k1i * i + li])
+    int B2[BN1][BN2];
+    char tname[] = "align121";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A1, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib, jb, j)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        for (j = 0; j < BN1; j++)
+        {
+            if (((i - li) ==(((i - li) / k1i) * k1i)) &&
+                (((i - li) / k1i) >= 0)  &&
+                (((i - li) / k1i) < BN2))
+            {
+                ib = j;
+                jb = (i - li) / k1i;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    };
+
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            int val = i * NL / 10 + j;
+            s = s + B2[i][j];
+            if (B2[i][j] != i * NL + j)
+                if (erri > val) erri = val;
+        }
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            cs = cs + i * NL + j;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN122*/
+/*  ALIGN arrB[i][] WITH arrA[2 * i + 1]*/
+void align122()
+{
+/*     parameters for ALIGN arrB[i][] WITH arrA[k1i * i + li]*/
+    #define AN1 16
+    #define AN2 0
+    #define BN1 4
+    #define BN2 4
+    int k1i = 2;
+    int li  = 1;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i][] with A1[k1i * i + li])
+    int B2[BN1][BN2];
+    char tname[] = "align122";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A1, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib, jb, j)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        for (j = 0; j < BN1; j++)
+        {
+            if (((i - li) ==(((i - li) / k1i) * k1i)) &&
+                (((i - li) / k1i) >= 0)  &&
+                (((i - li) / k1i) < BN2))
+            {
+                jb = j;
+                ib = (i - li) / k1i;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    }
+
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            int val = i * NL / 10 + j;
+            s = s + B2[i][j];
+            if (B2[i][j] != (i * NL + j))
+                if (erri > val) erri = val;
+        }
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            cs = cs + i * NL + j;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN123*/
+/*  ALIGN arrB[][] WITH arrA[]*/
+void align123()
+{
+/*     parameters for ALIGN arrB[][] WITH arrA[]*/
+    #define AN1 16
+    #define AN2 0
+    #define BN1 4
+    #define BN2 4
+    int k1i = 0;
+    int li = 0;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([][] with A1[])
+    int B2[BN1][BN2];
+    char tname[] = "align123";
+
+    erri = ER;
+
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A1, B2)
+    {
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = i * NL + j;
+    #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (ib = 0; ib < BN1; ib++)
+            for (jb = 0; jb < BN2; jb++)
+            {
+                int val = i * NL / 10 + j;
+                if (B2[ib][jb] != ib * NL + jb)
+                    if (erri > val) erri = val;
+            }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ALIGN/align214.cdv

@@ -0,0 +1,727 @@
+/*    ALIGN214
+TESTING align CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void align211();
+static void align212();
+static void align213();
+static void align214();
+
+static void align241();
+static void align2421();
+static void align2422();
+static void align243();
+static void align244();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+static int s, cs, erri, i, j, n, m, k, ia, ja, na, ma, ib, jb, nb, mb, Avalue, Bvalue;
+
+int main(int an, char **as)
+{
+    printf("=== START OF ALIGN214 ======================\n");
+
+/* ALIGN arrB[i] WITH arrA[1][i]   vector arrB on section
+                                              (the first line of arrA)*/
+    align211();
+/* ALIGN arrB[i] WITH arrA[2 * i + 2][2] vector arrB on section
+             (the second column of arrA) with stretching and shift*/
+    align212();
+/* ALIGN arrB[i] WITH arrA[][i] vector replication on every line of arrA*/
+    align213();
+/* ALIGN arrB[i] WITH arrA[2 * i + 2][] vector arrB on replication on
+             every column of arrA with stretching and shift*/
+    align214();
+
+/*  ALIGN arrB[i][j][][] WITH arrA[i][j]
+                     matrix compression*/
+    align241();
+/*  ALIGN arrB[][i][][j] WITH arrA[j+4][2*i] matrix compression*/
+    align2421();
+/*  ALIGN arrB[][i][][j] WITH arrA[j+1][2*i] small array*/
+    align2422();
+/*  ALIGN arrB[][][i][] WITH arrA[1][i] matrix compression
+                                        and replication*/
+    align243();
+/*  ALIGN arrB[][][][i] WITH arrA[i][] matrix compression
+                                    and replication*/
+    align244();
+
+    printf("=== END OF ALIGN214 ========================\n");
+    return 0;
+}
+/* ---------------------------------------------ALIGN211  */
+/* ALIGN arrB[i] WITH arrA[1][i]   vector arrB on section
+                                 (the first line of arrA)*/
+void align211()
+{
+/*    parameters for ALIGN arrB[i] WITH arrA[1][i]*/
+    #define AN1 8
+    #define AN2 8
+    #define BN1 4
+    int k1i = 0, k2i = 0, li = 1;
+    int k1j = 1, k2j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i] with A2[1][i])
+    int B1[BN1];
+    char tname[] = "align211";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if ((i == 1) && (j < BN1))
+            {
+                ib = j;
+                B1[ib] = ib;
+            }
+        }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = 1;
+        ja = i;
+        if (A2[ia][ja] != (ia * NL + ja))
+            if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+    }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN212*/
+/* ALIGN arrB[i] WITH arrA[2*i+2][2] vector arrB on section
+                    (the second column of arrA) with stretching and shift*/
+void align212()
+{
+    /*     parameters for ALIGN arrB[i] WITH arrA[2*i+2][2]*/
+    #define AN1 14
+    #define AN2 3
+    #define BN1 6
+    int k1i = 2, k2i = 0, li = 2;
+    int k1j = 0, k2j = 0, lj = 2;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i] with A2[k1i * i + li][lj])
+    int B1[BN1];
+    char tname[] = "align212";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (j == lj){
+                if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                    (((i - li) / k1i) >= 0) &&
+                    (((i - li) / k1i) < BN1))
+                {
+                    ib = (i - li) / k1i;
+                    B1[ib] = ib;
+                }
+            }
+        }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        ja = lj;
+        if (A2[ia][ja] != (ia * NL + ja))
+            if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+    }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN213*/
+/* ALIGN arrB[i] WITH arrA[][i]  vector replication on every line of arrA*/
+void align213()
+{
+/*     parameters for ALIGN arrB[i] WITH arrA[][k1j * i + lj]*/
+    #define AN1 8
+    #define AN2 8
+    #define BN1 6
+    int k1i = 0, k2i = 0, li = 0;
+    int k1j = 1, k2j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i] with A2[][k1j * i + lj])
+    int B1[BN1];
+    char tname[] = "align213";
+
+    erri = ER;
+    s = 0;
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A2, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = i;
+    #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), private(ib)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((j - lj) == (((j - lj) / k1j) * k1j)) &&
+                (((j - lj) / k1j) >= 0) &&
+                (((j - lj) / k1j) < BN1))
+            {
+                ib = (j - lj) / k1j;
+                if (B1[ib] != ib)
+                    if (erri > ib) erri = ib;
+            }
+        }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+    {
+        s = s + B1[i];
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+    }
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = (0 + BN1-1) * BN1 / 2;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//        printf("%d, %d, %d\n", erri, s, cs);
+    }
+    #undef AN1
+    #undef AN2
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN214*/
+/* ALIGN arrB[i] WITH arrA[2*i+2][ ] vector arrB on replication on
+             every column of arrA with stretching and shift*/
+void align214()
+{
+/*     parameters for ALIGN arrB[i] WITH arrA[k1i*i+li][]*/
+    #define AN1 28
+    #define AN2 8
+    #define BN1 5
+    int k1i = 2, k2i = 0, li = 2;
+    int k1j = 0, k2j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i] with A2[k1i * i + li][])
+    int B1[BN1];
+    char tname[] = "align214";
+
+    erri = ER;
+    s = 0;
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A2, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = i;
+    #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), private(ib)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                (((i - li) / k1i) >= 0) &&
+                (((i - li) / k1i) < BN1))
+            {
+                ib = (i - li) / k1i;
+                if (B1[ib] != ib)
+                    if (erri > i) erri = i;
+            }
+        }
+    #pragma dvm parallel([i] on B1[i]) reduction(sum(s))
+    for (i = 0; i < BN1; i++)
+        s = s + B1[i];
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = (0 + BN1-1) * BN1 / 2;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+}
+/* ---------------------------------------------ALIGN241  */
+/*  ALIGN arrB[i][j][][] WITH arrA[i][j]
+                     matrix compression*/
+void align241()
+{
+/*    parameters for ALIGN arrB[i][j][][] WITH arrA[k1i*i+li][k2j*j+lj]*/
+    #define AN1 5
+    #define AN2 5
+    #define BN1 2
+    #define BN2 2
+    #define BN3 2
+    #define BN4 2
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 0;
+    int k1j = 0, k2j = 1, k3j = 0, k4j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j][][] with A2[k1i*i+li][k2j*j+lj])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align241 ";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A2, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb, n, m, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL / 10 + j;
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                        ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                        (((i - li) / k1i) >= 0) &&
+                        (((j - lj) / k2j) >= 0) &&
+                        (((i - li) / k1i) < BN1) &&
+                        (((j - lj) / k2j) < BN2))
+                    {
+                        ib = (i - li) / k1i;
+                        jb = (j - lj) / k2j;
+                        nb = n;
+                        mb = m;
+                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+        }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] != val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN2421*/
+/*  ALIGN arrB[][i][][j] WITH arrA[j+4][2*i] matrix compression*/
+void align2421()
+{
+/*    parameters for ALIGN arrB[][i][][j] WITH arrA[k2i*j+li][k1j*i+lj]*/
+    #define AN1 12
+    #define AN2 9
+    #define BN1 4
+    #define BN2 4
+    #define BN3 4
+    #define BN4 4
+    int k1i = 0, k2i = 1, k3i = 0, k4i = 0, li = 4;
+    int k1j = 2, k2j = 0, k3j = 0, k4j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([][i][][j] with A2[k2i*j+li][k1j*i+lj])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align2421";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A2, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb, n, m, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL / 10 + j;
+            for (n = 0; n < BN1; n++)
+                for (m = 0; m < BN3; m++)
+                {
+                    if (((i - li) == (((i - li) / k2i) * k2i)) &&
+                        ((j - lj) == (((j - lj) / k1j) * k1j)) &&
+                        (((i - li) / k2i) >= 0) &&
+                        (((j - lj) / k1j) >= 0) &&
+                        (((i - li) / k2i) < BN4) &&
+                        (((j - lj) / k1j) < BN2))
+                    {
+                        ib = n;
+                        jb = (j - lj) / k1j;
+                        nb = m;
+                        mb = (i - li) / k2i;
+                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+        }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] != val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN2422*/
+/*  ALIGN arrB[][i][][j] WITH arrA[j+1][2*i] small array*/
+void align2422()
+{
+/*    parameters for ALIGN arrB[][i][][j] WITH arrA[k2i*j+li][k1j*i+lj]*/
+    #define AN1 3
+    #define AN2 4
+    #define BN1 2
+    #define BN2 2
+    #define BN3 2
+    #define BN4 2
+    int k1i = 0, k2i = 1, k3i = 0, k4i = 0, li = 1;
+    int k1j = 2, k2j = 0, k3j = 0, k4j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([][i][][j] with A2[k2i*j+li][k1j*i+lj])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align2422";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A2, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb, n, m, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL / 10 + j;
+            for (n = 0; n < BN1; n++)
+                for (m = 0; m < BN3; m++)
+                {
+                    if (((i - li) == (((i - li) / k2i) * k2i)) &&
+                        ((j - lj) == (((j - lj) / k1j) * k1j)) &&
+                        (((i - li) / k2i) >= 0) &&
+                        (((j - lj) / k1j) >= 0) &&
+                        (((i - li) / k2i) < BN4) &&
+                        (((j - lj) / k1j) < BN2))
+                    {
+                        ib = n;
+                        jb = (j - lj) / k1j;
+                        nb = m;
+                        mb = (i - li) / k2i;
+                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+        }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] != val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN243*/
+/*  ALIGN arrB[][][i][] WITH arrA[1][i] matrix compression
+                                        and replication*/
+void align243()
+{
+/*  parameters for ALIGN arrB[][][i][] WITH arrA[li][k1j*i+lj]*/
+    #define AN1 3
+    #define AN2 4
+    #define BN1 2
+    #define BN2 2
+    #define BN3 2
+    #define BN4 2
+    int k1i = 0, k2i = 0, k3i = 0, k4i = 0, li = 1;
+    int k1j = 1, k2j = 0, k3j = 0, k4j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([][][i][] with A2[li][k1j*i+lj])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align243 ";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A2, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb, k, n, m, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL / 10 + j;
+            if (i == li)
+                for (n = 0; n < BN1; n++)
+                    for (m = 0; m < BN2; m++)
+                        for (k = 0; k < BN4; k++)
+                        {
+                            if (((j - lj) == (((j - lj) / k1j) * k1j)) &&
+                                (((j - lj) / k1j) >= 0) &&
+                                (((j - lj) / k1j) < BN3))
+                            {
+                                ib = n;
+                                jb = m;
+                                nb = ((j - lj) / k1j);
+                                mb = k;
+                                B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                            }
+                        }
+        }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] != val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN244*/
+/*  ALIGN arrB[][][][i] WITH arrA[i][]  matrix compression
+                                    and replication*/
+void align244()
+{
+/*    parameters for ALIGN arrB[][][i][] WITH arrA[k1i*i+li][]*/
+    #define AN1 12
+    #define AN2 9
+    #define BN1 4
+    #define BN2 4
+    #define BN3 4
+    #define BN4 4
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 0;
+    int k1j = 0, k2j = 0, k3j = 0, k4j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([][][i][] with A2[k1i * i + li][])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align244 ";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A2, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), private(ib, jb, m, n, k, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL / 10 + j;
+            for (n = 0; n < BN1; n++)
+                for (m = 0; m < BN2; m++)
+                    for (k = 0; k < BN4; k++)
+                    {
+                        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                            (((i - li) / k1i) >= 0) &&
+                            (((i - li) / k1i) < BN3))
+                        {
+                            int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                            ib = n;
+                            jb = m;
+                            nb = ((i - li) / k1i);
+                            mb = k;
+                            if (B4[ib][jb][nb][mb] != ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb)
+                                if (erri > val) erri = val;
+                        }
+                    }
+        }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ALIGN/align22.cdv

@@ -0,0 +1,600 @@
+/*    ALIGN22
+TESTING align CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void align221();
+static void align222();
+static void align223();
+static void align224();
+static void align225();
+static void align2251();
+static void align226();
+static void align227();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+static int s, cs, erri, i, j, ia, ja, ib, jb;
+
+int main(int an, char **as)
+{
+    printf("=== START OF ALIGN22 ======================\n");
+            /* ALIGN arrB[i][j] WITH arrA[i][j] normal*/
+    align221();
+            /* ALIGN arrB[i][j] WITH arrA[i][2 * j] stretching along j*/
+    align222();
+            /* ALIGN arrB[i][j] WITH arrA[i + 4][j] shift along i*/
+    align223();
+             /* ALIGN arrB[i][j] WITH arrA[-i + 9][j] reverse on i*/
+//    align224();
+             /* ALIGN arrB[i][j] WITH arrA[i + 4][j + 4] shift along i and j*/
+    align225();
+             /*  */
+    align2251();
+             /* ALIGN arrB[i][j] WITH arrA[j][i] rotation*/
+    align226();
+             /* ALIGN arrB[i][j] WITH arrA[j + 1][i] rotation and shift*/
+    align227();
+
+    printf("=== END OF ALIGN22 ========================\n");
+    return 0;
+}
+/* ---------------------------------------------ALIGN221*/
+/* ALIGN arrB[i][j] WITH arrA[i][j] normal*/
+void align221()
+{
+/*     parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]*/
+    #define AN1 8
+    #define AN2 8
+    #define BN1 8
+    #define BN2 8
+    int k1i = 1, k2i = 0, li = 0;
+    int k1j = 0, k2j = 1, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k1i * i + li][k2j * j + lj])
+    int B2[BN1][BN2];
+    char tname[] = "align221 ";
+
+    erri = ER;
+
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for(j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                (((i - li) / k1i) >= 0) &&
+                (((j - lj) / k2j) >= 0) &&
+                (((i - li) / k1i) < BN1) &&
+                (((j - lj) / k2j) < BN2))
+            {
+                ib = (i - li) / k1i;
+                jb = (j - lj) / k2j;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+        }
+
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN222*/
+/* ALIGN arrB[i][j] WITH arrA[i][2*j] stretching along j*/
+void align222()
+{
+/*    parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]*/
+    #define AN1 8
+    #define AN2 8
+    #define BN1 8
+    #define BN2 4
+    int k1i = 1, k2i = 0, li = 0;
+    int k1j = 0, k2j = 2, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k1i * i + li][k2j * j + lj])
+    int B2[BN1][BN2];
+    char tname[] = "align222 ";
+
+    erri = ER;
+
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for(j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                (((i - li) / k1i) >= 0) &&
+                (((j - lj) / k2j) >= 0) &&
+                (((i - li) / k1i) < BN1) &&
+                (((j - lj) / k2j) < BN2))
+            {
+                ib = (i - li) / k1i;
+                jb = (j - lj) / k2j;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+        }
+
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN223*/
+/* ALIGN arrB[i][j] WITH arrA[i+4][j] shift along i*/
+void align223()
+{
+/*    parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]*/
+    #define AN1 8
+    #define AN2 8
+    #define BN1 4
+    #define BN2 8
+    int k1i = 1, k2i = 0, li = 4;
+    int k1j = 0, k2j = 1, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k1i * i + li][k2j * j + lj])
+    int B2[BN1][BN2];
+    char tname[] = "align223 ";
+
+    erri = ER;
+
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for(j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                (((i - li) / k1i) >= 0) &&
+                (((j - lj) / k2j) >= 0) &&
+                (((i - li) / k1i) < BN1) &&
+                (((j - lj) / k2j) < BN2))
+            {
+                ib = (i - li) / k1i;
+                jb = (j - lj) / k2j;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+        }
+
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN224*/
+/* ALIGN arrB[i][j] WITH arrA[-i+9][j]  reverse on i*/
+void align224()
+{
+/*    parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]*/
+    #define AN1 10
+    #define AN2 8
+    #define BN1 8
+    #define BN2 8
+    int k1i = -1, k2i = 0, li = 9;
+    int k1j = 0, k2j = 1, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k1i * i + li][k2j * j + lj])
+    int B2[BN1][BN2];
+    char tname[] = "align224 ";
+
+    erri = ER;
+
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for(j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                (((i - li) / k1i) >= 0) &&
+                (((j - lj) / k2j) >= 0) &&
+                (((i - li) / k1i) < BN1) &&
+                (((j - lj) / k2j) < BN2))
+            {
+                ib = (i - li) / k1i;
+                jb = (j - lj) / k2j;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+        }
+
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN225*/
+/* ALIGN arrB[i][j] WITH arrA[i+4][j+4]shift along i and j*/
+void align225()
+{
+/*    parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]*/
+    #define AN1 8
+    #define AN2 8
+    #define BN1 4
+    #define BN2 4
+    int k1i = 1, k2i = 0, li = 4;
+    int k1j = 0, k2j = 1, lj = 4;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k1i * i + li][k2j * j + lj])
+    int B2[BN1][BN2];
+    char tname[] = "align225 ";
+
+    erri = ER;
+
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for(j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                (((i - li) / k1i) >= 0) &&
+                (((j - lj) / k2j) >= 0) &&
+                (((i - li) / k1i) < BN1) &&
+                (((j - lj) / k2j) < BN2))
+            {
+                ib = (i - li) / k1i;
+                jb = (j - lj) / k2j;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+        }
+
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN2251*/
+/* ALIGN arrB[i][j] WITH arrA[i+1][2*j] small arrays*/
+void align2251()
+{
+/*    parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]*/
+    #define AN1 3
+    #define AN2 5
+    #define BN1 2
+    #define BN2 3
+    int k1i = 1, k2i = 0, li = 1;
+    int k1j = 0, k2j = 2, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k1i * i + li][k2j * j + lj])
+    int B2[BN1][BN2];
+    char tname[] = "align2251";
+
+    erri = ER;
+
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for(j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                (((i - li) / k1i) >= 0) &&
+                (((j - lj) / k2j) >= 0) &&
+                (((i - li) / k1i) < BN1) &&
+                (((j - lj) / k2j) < BN2))
+            {
+                ib = (i - li) / k1i;
+                jb = (j - lj) / k2j;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+        }
+
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN226*/
+/* ALIGN arrB[i][j] WITH arrA[j][i] rotation*/
+void align226()
+{
+/*    parameters for ALIGN arrB[i][j] WITH arrA[k2i * j + li][k1j * i + lj]*/
+    #define AN1 4
+    #define AN2 4
+    #define BN1 4
+    #define BN2 4
+    int k1i = 0, k2i = 1, li = 0;
+    int k1j = 1, k2j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k2i * j + li][k1j * i + lj])
+    int B2[BN1][BN2];
+    char tname[] = "align226 ";
+
+    erri = ER;
+
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k2i) * k2i)) &&
+                ((j - lj) == (((j - lj) / k1j) * k1j)) &&
+                (((i - li) / k2i) >= 0) &&
+                (((j - lj) / k1j) >= 0) &&
+                (((i - li) / k2i) < BN2) &&
+                (((j - lj) / k1j) < BN1))
+            {
+                jb = (i - li) / k2i;
+                ib = (j - lj) / k1j;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+            ia = k2i * j + li;
+            ja = k1j * i + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+        }
+
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN227*/
+/* ALIGN arrB[i][j] WITH arrA[j+1][i] rotation and shift*/
+void align227()
+{
+/*    parameters for ALIGN arrB[i][j] WITH arrA[k2i*j+li][k1j*i+lj]*/
+    #define AN1 8
+    #define AN2 8
+    #define BN1 4
+    #define BN2 4
+    int k1i = 0, k2i = 1, li = 1;
+    int k1j = 1, k2j = 0, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k2i * j + li][k1j * i + lj])
+    int B2[BN1][BN2];
+    char tname[] = "align227 ";
+
+    erri = ER;
+
+    #pragma dvm actual(erri)
+    #pragma dvm region local(A2, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k2i) * k2i)) &&
+                ((j - lj) == (((j - lj) / k1j) * k1j)) &&
+                (((i - li) / k2i) >= 0) &&
+                (((j - lj) / k1j) >= 0) &&
+                (((i - li) / k2i) < BN2) &&
+                (((j - lj) / k1j) < BN1))
+            {
+                jb = (i - li) / k2i;
+                ib = (j - lj) / k1j;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+            ia = k2i * j + li;
+            ja = k1j * i + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                if (erri > i * NL / 10 + j) erri = i * NL / 10 + j;
+        }
+
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ALIGN/align32.cdv

@@ -0,0 +1,600 @@
+/*    ALIGN32
+TESTING align CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void align321();
+static void align322();
+static void align323();
+static void align324();
+static void align325();
+static void align326();
+static void align327();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+static int s, cs, erri, i, j, n, m, k, l, ia, ja, na, ma, ib, jb, nb, mb, Avalue, Bvalue;
+
+int main(int an, char **as)
+{
+    printf("=== START OF ALIGN32 ======================\n");
+/*  ALIGN arrB[i][j] WITH arrA[i][j][1] matrix on section*/
+    align321();
+/*  ALIGN arrB[i][j] WITH arrA[j][i][5] matrix on section with rotation*/
+    align322();
+/*  ALIGN arrB[i][j] WITH arrA[j][1][2*i] matrix on section with
+                                          rotation and stretching*/
+    align323();
+/*  ALIGN arrB[i][j] WITH arrA[][i][j] matrix replication*/
+    align324();
+/*  ALIGN arrB[i][j] WITH arrA[i+4][][j] matrix replication with shift*/
+    align325();
+/*  ALIGN arrB[i][j] WITH  arrA[-i+8][j][] matrix replication with reverse*/
+//    align326();
+/*  ALIGN arrB[][] WITH arrA[][][]*/
+    align327();
+    printf("=== END OF ALIGN32 ========================\n");
+    return 0;
+}
+/* ---------------------------------------------ALIGN321*/
+/* ALIGN arrB[i][j] WITH arrA[i][j][1] matrix on section*/
+void align321()
+{
+/*     parameters for ALIGN arrB[i][j]
+                      WITH arrA[k1i*i+li][k2j*j+lj][ln]*/
+    #define AN1 5
+    #define AN2 5
+    #define AN3 5
+    #define BN1 4
+    #define BN2 4
+    int k1i = 1, k2i = 0, k3i = 0, li = 0;
+    int k1j = 0, k2j = 1, k3j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 0, ln = 1;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j] with A3[k1i*i+li][k2j*j+lj][ln])
+    int B2[BN1][BN2];
+    char tname[] = "align321";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A3, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+            {
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n;
+                if ((n == ln ) &&
+                    ((i - li) == (((i - li) / k1i) * k1i)) &&
+                    ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                    (((i - li) / k1i) >= 0) &&
+                    (((j - lj) / k2j) >= 0) &&
+                    (((i - li) / k1i) < BN1) &&
+                    (((j - lj) / k2j) < BN2))
+                {
+                    ib = (i - li) / k1i;
+                    jb = (j - lj) / k2j;
+                    B2[ib][jb] = ib * NL / 10 + jb * NL / 100;
+                }
+            }
+
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri), sum(s)), private(ia, ja, na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            int val = i * NL / 10 + j * NL / 100;
+            s = s + B2[i][j];
+            if (B2[i][j] != val)
+                if (erri > val) erri = val;
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            na = ln;
+            if (A3[ia][ja][na] != ia * NL / 10 + ja * NL / 100 + na)
+                if (erri > val) erri = val;
+        }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            cs = cs + i * NL / 10 + j * NL / 100;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN322*/
+/* ALIGN arrB[i][j] WITH arrA[j][i][5] matrix on section with rotation*/
+void align322()
+{
+/*     parameters for ALIGN arrB[i][j]
+                      WITH arrA[k2i*j+li][k1j*i+lj][ln]*/
+    #define AN1 5
+    #define AN2 5
+    #define AN3 6
+    #define BN1 4
+    #define BN2 4
+    int k1i = 0, k2i = 1, k3i = 0, li = 0;
+    int k1j = 1, k2j = 0, k3j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 0, ln = 5;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j] with A3[k2i*j+li][k1j*i+lj][ln])
+    int B2[BN1][BN2];
+    char tname[] = "align322";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A3, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+            {
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n;
+                if ((n == ln ) &&
+                    ((i - li) == (((i - li) / k2i) * k2i)) &&
+                    ((j - lj) == (((j - lj) / k1j) * k1j)) &&
+                    (((i - li) / k2i) >= 0) &&
+                    (((j - lj) / k1j) >= 0) &&
+                    (((i - li) / k2i) < BN2) &&
+                    (((j - lj) / k1j) < BN1))
+                {
+                    ib = (j - lj) / k1j;
+                    jb = (i - li) / k2i;
+                    B2[ib][jb] = ib * NL / 10 + jb * NL / 100;
+                }
+            }
+
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri), sum(s)), private(ia, ja, na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            int val = i * NL / 10 + j * NL / 100;
+            s = s + B2[i][j];
+            if (B2[i][j] != val)
+                if (erri > val) erri = val;
+            ia = k2i * j + li;
+            ja = k1j * i + lj;
+            na = ln;
+            if (A3[ia][ja][na] != ia * NL / 10 + ja * NL / 100 + na)
+                if (erri > val) erri = val;
+        }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            cs = cs + i * NL / 10 + j * NL / 100;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN323*/
+/* ALIGN arrB[i][j] WITH arrA[j][1][2*i] matrix on section with
+                                         rotation and stretching*/
+void align323()
+{
+/*     parameters for ALIGN arrB[i][j]
+                      WITH arrA[k2i*j+li][lj][k1n*i+ln]*/
+    #define AN1 5
+    #define AN2 2
+    #define AN3 7
+    #define BN1 4
+    #define BN2 4
+    int k1i = 0, k2i = 1, k3i = 0, li = 0;
+    int k1j = 0, k2j = 0, k3j = 0, lj = 1;
+    int k1n = 2, k2n = 0, k3n = 0, ln = 0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j] with A3[k2i*j+li][lj][k1n*i+ln])
+    int B2[BN1][BN2];
+    char tname[] = "align323";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A3, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+            {
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n;
+                if ((j == lj) &&
+                    ((i - li) == (((i - li) / k2i) * k2i)) &&
+                    ((n - ln) == (((n - ln) / k1n) * k1n)) &&
+                    (((i - li) / k2i) >= 0) &&
+                    (((n - ln) / k1n) >= 0) &&
+                    (((i - li) / k2i) < BN2) &&
+                    (((n - ln) / k1n) < BN1))
+                {
+                    ib = (n - ln) / k1n;
+                    jb = (i - li) / k2i;
+                    B2[ib][jb] = ib * NL / 10 + jb * NL / 100;
+                }
+            }
+
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri), sum(s)), private(ia, ja, na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            int val = i * NL / 10 + j * NL / 100;
+            s = s + B2[i][j];
+            if (B2[i][j] != val)
+                if (erri > val) erri = val;
+            ia = k2i * j + li;
+            ja = lj;
+            na = k1n * i + ln;
+            if (A3[ia][ja][na] != ia * NL / 10 + ja * NL / 100 + na)
+                if (erri > val) erri = val;
+        }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            cs = cs + i * NL / 10 + j * NL / 100;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN324*/
+/* ALIGN arrB[i][j] WITH arrA[][i][j] matrix replication*/
+void align324()
+{
+/*     parameters for ALIGN arrB[i][j]
+                      WITH arrA[][k1j*i+lj][k2n*j+ln]*/
+    #define AN1 4
+    #define AN2 6
+    #define AN3 6
+    #define BN1 4
+    #define BN2 4
+    int k1i = 0, k2i = 0, k3i = 0, li = 0;
+    int k1j = 1, k2j = 0, k3j = 0, lj = 0;
+    int k1n = 0, k2n = 1, k3n = 0, ln = 0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j] with A3[][k1j*i+lj][k2n*j+ln])
+    int B2[BN1][BN2];
+    char tname[] = "align324";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A3, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = i * NL / 10 + j * NL / 100;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) reduction(min(erri)), private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+            {
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n;
+                if (((n - ln) == (((n - ln) / k2n) * k2n)) &&
+                    ((j - lj) == (((j - lj) / k1j) * k1j)) &&
+                    (((n - ln) / k2n) >= 0) &&
+                    (((j - lj) / k1j) >= 0) &&
+                    (((n - ln) / k2n) < BN2) &&
+                    (((j - lj) / k1j) < BN1))
+                {
+                    int val = i * NL / 10 + j * NL / 100;
+                    ib = (j - lj) / k1j;
+                    jb = (n - ln) / k2n;
+                    if (B2[ib][jb] != ib * NL / 10 + jb * NL / 100)
+                        if (erri > val) erri = val;
+                }
+            }
+
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri), sum(s)), private(ia, ja, na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            int val = i * NL / 10 + j * NL / 100;
+            s = s + B2[i][j];
+            if (B2[i][j] != val)
+                if (erri > val) erri = val;
+        }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            cs = cs + i * NL / 10 + j * NL / 100;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN325*/
+/*	ALIGN arrB[i][j] WITH arrA[i+4][][j] matrix replication with shift*/
+void align325()
+{
+/*     parameters for ALIGN arrB[i][j]
+                      WITH arrA[k1i*i+li][][k2n * j + ln]*/
+    #define AN1 12
+    #define AN2 6
+    #define AN3 6
+    #define BN1 4
+    #define BN2 4
+    int k1i = 1, k2i = 0, k3i = 0, li  = 4;
+    int k1j = 1, k2j = 0, k3j = 0, lj  = 0;
+    int k1n = 0, k2n = 1, k3n = 0, ln  = 0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j] with A3[k1i*i+li][][k2n*j+ln])
+    int B2[BN1][BN2];
+    char tname[] = "align325";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A3, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = i * NL / 10 + j * NL / 100;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) reduction(min(erri)), private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+            {
+                A3[i][j][n] = i*NL/10 + j*NL/100 + n;
+                if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                    ((n - ln) == (((n - ln) / k2n) * k2n)) &&
+                    (((i - li) / k1i) >= 0) &&
+                    (((n - ln) / k2n) >= 0) &&
+                    (((i - li) / k1i) < BN1) &&
+                    (((n - ln) / k2n) < BN2))
+                {
+                    int val = i * NL / 10 + j * NL / 100;
+                    ib = (i - li) / k1i;
+                    jb = (n - ln) / k2n;
+                    if (B2[ib][jb] != ib * NL / 10 + jb * NL / 100)
+                        if (erri > val) erri = val;
+                }
+            }
+
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri), sum(s)), private(ia, ja, na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            int val = i * NL / 10 + j * NL / 100;
+            s = s + B2[i][j];
+            if (B2[i][j] != val)
+                if (erri > val) erri = val;
+        }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            cs = cs + i * NL / 10 + j * NL / 100;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN326*/
+/*	ALIGN arrB[i][j] WITH arrA[-i+8][j][] matrix replication with reverse*/
+void align326()
+{
+/*     parameters for ALIGN arrB[i][j]
+                      WITH arrA[k1i*i+li][k2j*j+lj][]*/
+    #define AN1 9
+    #define AN2 5
+    #define AN3 5
+    #define BN1 7
+    #define BN2 4
+    int k1i = -1, k2i = 0, k3i = 0, li = 8;
+    int k1j = 0, k2j = 1, k3j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 0, ln = 0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j] with A3[k1i*i+li][k2j*j+lj][])
+    int B2[BN1][BN2];
+    char tname[] = "align326";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A3, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = i * NL / 10 + j * NL / 100;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) reduction(min(erri)), private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+            {
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n;
+                if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                    ((j - lj) == (((j  -lj) / k2j) * k2j)) &&
+                    (((i - li) / k1i) >= 0) &&
+                    (((j - lj) / k2j) >= 0) &&
+                    (((i - li) / k1i) < BN1) &&
+                    (((j - lj) / k2n) < BN2))
+                {
+                    int val = i * NL / 10 + j * NL / 100;
+                    ib = (i - li) / k1i;
+                    jb = (j - lj) / k2j;
+                    if (B2[ib][jb] != ib * NL / 10 + jb * NL / 100)
+                        if (erri > val) erri = val;
+                }
+            }
+
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erri), sum(s)), private(ia, ja, na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            int val = i * NL / 10 + j * NL / 100;
+            s = s + B2[i][j];
+            if (B2[i][j] != val)
+                if (erri > val) erri = val;
+        }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            cs = cs + i * NL / 10 + j * NL / 100;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------ALIGN327*/
+/*  ALIGN arrB[][] WITH arrA[][][]*/
+void align327()
+{
+/*     parameters for ALIGN arrB[][]
+                      WITH arrA[][][]*/
+    #define AN1 7
+    #define AN2 5
+    #define AN3 5
+    #define BN1 7
+    #define BN2 4
+    int k1i = 0, k2i = 0, k3i = 0, li = 0;
+    int k1j = 0, k2j = 0, k3j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 0, ln = 1;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([][] with A3[][][])
+    int B2[BN1][BN2];
+    char tname[] = "align327";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A3, B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = i * NL / 10 + j * NL / 100;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) reduction(min(erri)), private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+            {
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n;
+                for (ib = 0; ib < BN1; ib++)
+                    for (jb = 0; jb < BN2; jb++)
+                    {
+                        int val = i * NL / 10 + j * NL / 100;
+                        if (B2[ib][jb] != ib * NL / 10 + jb * NL / 100)
+                            if (erri > val) erri = val;
+                    }
+            }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ALIGN/align33.cdv

@@ -0,0 +1,197 @@
+/*    ALIGN33
+TESTING align CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void align331();
+static void align332();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+static int s, cs, erri, i, j, n, m, k, l, ia, ja, na, ma, ib, jb, nb, mb, Avalue, Bvalue;
+
+int main(int an, char **as)
+{
+    printf("=== START OF ALIGN33 ======================\n");
+            /* ALIGN arrB[i][j][k] WITH arrA[i][j][k] normal*/
+    align331();
+            /* ALIGN arrB[][i][] WITH arrA[][lj][i]*/
+    align332();
+    printf("=== END OF ALIGN33 ========================\n");
+    return 0;
+}
+/* ---------------------------------------------ALIGN331*/
+/* ALIGN arrB[i][j][n] WITH arrA[i][j][n] normal*/
+void align331()
+{
+/*     parameters for ALIGN arrB[i][j][n]
+                      WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln]*/
+    #define AN1 5
+    #define AN2 5
+    #define AN3 5
+    #define BN1 2
+    #define BN2 2
+    #define BN3 2
+    int k1i = 1, k2i = 0, k3i = 0, li = 0;
+    int k1j = 0, k2j = 1, k3j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 1, ln = 0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j][n] with A3[k1i*i+li][k2j*j+lj][k3n*n+ln])
+    int B3[BN1][BN2][BN3];
+    char tname[] = "align331";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A3, B3)
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = 0;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib, jb, nb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+            {
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+                if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                    ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                    ((n - ln) == (((n - ln) / k3n) * k3n)) &&
+                    (((i - li) / k1i) >= 0) &&
+                    (((j - lj) / k2j) >= 0) &&
+                    (((n - ln) / k3n) >= 0) &&
+                    (((i - li) / k1i) < BN1) &&
+                    (((j - lj) /k2j) < BN2) &&
+                    (((n - ln) / k3n) < BN3))
+                {
+                    ib = (i - li) / k1i;
+                    jb = (j - lj) / k2j;
+                    nb = (n - ln) / k3n;
+                    B3[ib][jb][nb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000;
+                }
+            }
+
+    #pragma dvm parallel([i][j][n] on B3[i][j][n]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+            {
+                int val = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+                s = s + B3[i][j][n];
+                if (B3[i][j][n] != val)
+                    if (erri > val) erri = val;
+            }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+/* ---------------------------------------------ALIGN332*/
+/* ALIGN arrB[][i][] WITH arrA[][lj][i]*/
+void align332()
+{
+/*     parameters for ALIGN arrB[][i][]
+                      WITH arrA[][lj][k3n*n+ln]*/
+    #define AN1 4
+    #define AN2 4
+    #define AN3 4
+    #define BN1 2
+    #define BN2 2
+    #define BN3 2
+    int k1i = 0, k2i = 0, k3i = 0, li = 0;
+    int k1j = 0, k2j = 0, k3j = 0, lj = 3;
+    int k1n = 1, k2n = 0, k3n = 0, ln = 0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([][i][] with A3[][lj][k1n*i+ln])
+    int B3[BN1][BN2][BN3];
+    char tname[] = "align332";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A3, B3)
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib, jb, nb, k, l), reduction(min(erri))
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+            {
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+                if (j == lj)
+                {
+                    for (k = 0; k < BN1; k++)
+                        for (l = 0; l < BN3; l++)
+                        {
+                            if (((n - ln) == (((n - ln) / k1n) * k1n)) &&
+                                (((n - ln) / k1n) >= 0) &&
+                                (((n - ln) / k1n) < BN2))
+                            {
+                                int val = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+                                ib = k;
+                                jb = (n - ln) / k1n;
+                                nb = l;
+                                if (B3[ib][jb][nb] != ib * NL / 10 + jb * NL / 100 + nb * NL / 1000)
+                                    if (erri > val) erri = val;
+                            }
+                        }
+                }
+            }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ALIGN/align44.cdv

@@ -0,0 +1,855 @@
+/*    ALIGN44
+TESTING align CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void align441();
+static void align442();
+static void align443();
+static void align444();
+static void align445();
+static void align446();
+static void align447();
+static void align448();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+static int s, cs, erri, i, j, n, m, k, l, ia, ja, na, ma, ib, jb, nb, mb, Avalue, Bvalue;
+
+int main(int an, char **as)
+{
+    printf("=== START OF ALIGN44 ======================\n");
+            /* ALIGN arrB[i][j][k][l] WITH arrA[i][j][k][l] normal*/
+    align441();
+            /* ALIGN arrB[i][j][k][l] WITH arrA[l][i][j][k] rotation*/
+    align442();
+            /* ALIGN arrB[i][j][k][l] WITH arrA[i][2* j][k][3*l] stretching*/
+    align443();
+             /* ALIGN arrB[i][j][k][l] WITH arrA[i+2][j][k][l+3] shift*/
+    align444();
+             /* ALIGN arrB[i][j][k][l] WITH arrA[i][j][-k+8][l+8] reverse*/
+//    align445();
+             /* ALIGN arrB[i][j][][l] WITH arrA[i][j][2][l]
+                compression and replication*/
+    align446();
+             /* ALIGN arrB[][j][k][i] WITH arrA[i][j][][k]
+                compression and replication*/
+    align447();
+             /* ALIGN arrB[][i][j][] WITH arrA[i][j][1][3]
+                compression and replication*/
+    align448();
+    printf("=== END OF ALIGN44 ========================\n");
+    return 0;
+}
+/* ---------------------------------------------ALIGN441*/
+/* ALIGN arrB[i][j][n][m] WITH arrA[i][ j][n][m] normal*/
+void align441()
+{
+/*     parameters for ALIGN arrB[i][j][n][m]
+                      WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm]*/
+    #define AN1 5
+    #define AN2 5
+    #define AN3 5
+    #define AN4 5
+    #define BN1 2
+    #define BN2 2
+    #define BN3 2
+    #define BN4 2
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 0;
+    int k1j = 0, k2j = 1, k3j = 0, k4j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 1, k4n = 0, ln = 0;
+    int k1m = 0, k2m = 0, k3m = 0, k4m = 1, lm = 0;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([i][j][n][m] with A4[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align441";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A4, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                        ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                        ((n - ln) == (((n - ln) / k3n) * k3n)) &&
+                        ((m - lm) == (((m - lm) / k4m) * k4m)) &&
+                        (((i - li) / k1i) >= 0) &&
+                        (((j - lj) / k2j) >= 0) &&
+                        (((n - ln) / k3n) >= 0) &&
+                        (((m - lm) / k4m) >= 0) &&
+                        (((i - li) / k1i) < BN1) &&
+                        (((j - lj) / k2j) < BN2) &&
+                        (((n - ln) / k3n) < BN3) &&
+                        (((m - lm) / k4m) < BN4))
+                    {
+                        ib = (i - li) / k1i;
+                        jb = (j - lj) / k2j;
+                        nb = (n - ln) / k3n;
+                        mb = (m - lm) / k4m;
+                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] !=val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN442*/
+/* ALIGN arrB[i][j][k][l] WITH arrA[l][i][j][k]  rotation*/
+void align442()
+{
+/*     parameters for ALIGN arrB[i][j][n][m]
+                      WITH arrA4[k4i*n+li][k1j*i+lj][k2n*j+ln][k3m*n+lm]*/
+    #define AN1 4
+    #define AN2 4
+    #define AN3 4
+    #define AN4 4
+    #define BN1 4
+    #define BN2 4
+    #define BN3 4
+    #define BN4 4
+    int k1i = 0, k2i = 0, k3i = 0, k4i = 1, li = 0;
+    int k1j = 1, k2j = 0, k3j = 0, k4j = 0, lj = 0;
+    int k1n = 0, k2n = 1, k3n = 0, k4n = 0, ln = 0;
+    int k1m = 0, k2m = 0, k3m = 1, k4m = 0, lm = 0;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([i][j][n][m] with A4[k4i*m+li][k1j*i+lj][k2n*j+ln][k3m*n+lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align442";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A4, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    if (((i - li) == (((i - li) / k4i) * k4i)) &&
+                        ((j - lj) == (((j - lj) / k1j) * k1j)) &&
+                        ((n - ln) == (((n - ln) / k2n) * k2n)) &&
+                        ((m - lm) == (((m - lm) / k3m) * k3m)) &&
+                        (((i - li) / k4i) >= 0) &&
+                        (((j - lj) / k1j) >= 0) &&
+                        (((n - ln) / k2n) >= 0) &&
+                        (((m - lm) / k3m) >= 0) &&
+                        (((i - li) / k4i) < BN4) &&
+                        (((j - lj) / k1j) < BN1) &&
+                        (((n - ln) / k2n) < BN2) &&
+                        (((m - lm) / k3m) < BN3))
+                    {
+                        mb = (i - li) / k4i;
+                        ib = (j - lj) / k1j;
+                        jb = (n - ln) / k2n;
+                        nb = (m - lm) / k3m;
+                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] !=val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN443*/
+/* ALIGN arrB[i][j][k][l] WITH arrA[i][2* j][k][3*l] stretching*/
+void align443()
+{
+/*     parameters for ALIGN arrB[i][j][n][m]
+                      WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm]*/
+    #define AN1 5
+    #define AN2 4
+    #define AN3 3
+    #define AN4 7
+    #define BN1 3
+    #define BN2 2
+    #define BN3 2
+    #define BN4 3
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 0;
+    int k1j = 0, k2j = 2, k3j = 0, k4j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 1, k4n = 0, ln = 0;
+    int k1m = 0, k2m = 0, k3m = 0, k4m = 3, lm = 0;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([i][j][n][m] with A4[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align443";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A4, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                        ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                        ((n - ln) == (((n - ln) / k3n) * k3n)) &&
+                        ((m - lm) == (((m - lm) / k4m) * k4m)) &&
+                        (((i - li) / k1i) >= 0) &&
+                        (((j - lj) / k2j) >= 0) &&
+                        (((n - ln) / k3n) >= 0) &&
+                        (((m - lm) / k4m) >= 0) &&
+                        (((i - li) / k1i) < BN1) &&
+                        (((j - lj) / k2j) < BN2) &&
+                        (((n - ln) / k3n) < BN3) &&
+                        (((m - lm) / k4m) < BN4))
+                    {
+                        ib = (i - li) / k1i;
+                        jb = (j - lj) / k2j;
+                        nb = (n - ln) / k3n;
+                        mb = (m - lm) / k4m;
+                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] !=val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN444*/
+/* ALIGN arrB[i][j][k][l] WITH arrA[i+2][j][k][l+3] shift*/
+void align444()
+{
+/*     parameters for ALIGN arrB[i][j][n][m]
+                      WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm]*/
+    #define AN1 4
+    #define AN2 4
+    #define AN3 3
+    #define AN4 6
+    #define BN1 2
+    #define BN2 2
+    #define BN3 2
+    #define BN4 2
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 2;
+    int k1j = 0, k2j = 1, k3j = 0, k4j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 1, k4n = 0, ln = 0;
+    int k1m = 0, k2m = 0, k3m = 0, k4m = 1, lm = 3;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([i][j][n][m] with A4[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align444";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A4, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                        ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                        ((n - ln) == (((n - ln) / k3n) * k3n)) &&
+                        ((m - lm) == (((m - lm) / k4m) * k4m)) &&
+                        (((i - li) / k1i) >= 0) &&
+                        (((j - lj) / k2j) >= 0) &&
+                        (((n - ln) / k3n) >= 0) &&
+                        (((m - lm) / k4m) >= 0) &&
+                        (((i - li) / k1i) < BN1) &&
+                        (((j - lj) / k2j) < BN2) &&
+                        (((n - ln) / k3n) < BN3) &&
+                        (((m - lm) / k4m) < BN4))
+                    {
+                        ib = (i - li) / k1i;
+                        jb = (j - lj) / k2j;
+                        nb = (n - ln) / k3n;
+                        mb = (m - lm) / k4m;
+                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] !=val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN445*/
+/* ALIGN arrB[i][j][k][l] WITH arrA[i][j][-k+4][-l+3] reverse*/
+void align445()
+{
+/*     parameters for ALIGN arrB[i][j][n][m]
+                      WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm]*/
+    #define AN1 4
+    #define AN2 4
+    #define AN3 8
+    #define AN4 6
+    #define BN1 3
+    #define BN2 3
+    #define BN3 5
+    #define BN4 4
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 0;
+    int k1j = 0, k2j = 1, k3j = 0, k4j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = -1, k4n = 0, ln = 4;
+    int k1m = 0, k2m = 0, k3m = 0, k4m = -1, lm = 3;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([i][j][n][m] with A4[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align445";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A4, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                        ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                        ((n - ln) == (((n - ln) / k3n) * k3n)) &&
+                        ((m - lm) == (((m - lm) / k4m) * k4m)) &&
+                        (((i - li) / k1i) >= 0) &&
+                        (((j - lj) / k2j) >= 0) &&
+                        (((n - ln) / k3n) >= 0) &&
+                        (((m - lm) / k4m) >= 0) &&
+                        (((i - li) / k1i) < BN1) &&
+                        (((j - lj) / k2j) < BN2) &&
+                        (((n - ln) / k3n) < BN3) &&
+                        (((m - lm) / k4m) < BN4))
+                    {
+                        ib = (i - li) / k1i;
+                        jb = (j - lj) / k2j;
+                        nb = (n - ln) / k3n;
+                        mb = (m - lm) / k4m;
+                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] !=val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN446*/
+/* ALIGN arrB[i][j][][l] WITH arrA[i][j][2][l]
+                compression and replication*/
+void align446()
+{
+/*    parameters for ALIGN arrB[i][j][][m] WITH arrA4[k1i*i+li][k2j*j+lj][ln][k4m*m+lm]*/
+    #define AN1 4
+    #define AN2 4
+    #define AN3 4
+    #define AN4 4
+    #define BN1 2
+    #define BN2 2
+    #define BN3 2
+    #define BN4 2
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li  = 0;
+    int k1j = 0, k2j = 1, k3j = 0, k4j = 0, lj  = 0;
+    int k1n = 0, k2n = 0, k3n = 0, k4n = 0, ln  = 2;
+    int k1m = 0, k2m = 0, k3m = 0, k4m = 1, lm  = 0;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([i][j][][m] with A4[k1i*i+li][k2j*j+lj][ln][k4m*m+lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align446";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A4, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb, k)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    if (n == ln)
+                    {
+                        for (k = 0; k < BN3; k++)
+                        {
+                            if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                                ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                                ((m - lm) == (((m - lm) / k4m) * k4m)) &&
+                                (((i - li) / k1i) >= 0) &&
+                                (((j - lj) / k2j) >= 0) &&
+                                (((m - lm) / k4m) >= 0) &&
+                                (((i - li) / k1i) < BN1) &&
+                                (((j - lj) / k2j) < BN2) &&
+                                (((m - lm) / k4m) < BN4))
+                            {
+                                ib = (i - li) / k1i;
+                                jb = (j - lj) / k2j;
+                                nb = k;
+                                mb = (m - lm) / k4m;
+                                B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                            }
+                        }
+                    }
+                }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] !=val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN447*/
+/* ALIGN arrB[][j][k][i] WITH arrA[i][j][][k]
+                compression and replication*/
+void align447()
+{
+/*   parameters for ALIGN arrB[][j][n][i] WITH arrA4[k1i*i+li][k2j*j+lj][][k3m*n+lm]*/
+    #define AN1 4
+    #define AN2 4
+    #define AN3 4
+    #define AN4 4
+    #define BN1 4
+    #define BN2 4
+    #define BN3 4
+    #define BN4 4
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 0;
+    int k1j = 0, k2j = 1, k3j = 0, k4j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 0, k4n = 0, ln = 0;
+    int k1m = 0, k2m = 0, k3m = 1, k4m = 0, lm = 0;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([][j][n][i] with A4[k1i*i+li][k2j*j+lj][][k3m*n+lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align447";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A4, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb, k)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    for (k = 0; k < BN1; k++)
+                    {
+                        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                            ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                            ((m - lm) == (((m - lm) / k3m) * k3m)) &&
+                            (((i - li) / k1i) >= 0) &&
+                            (((j - lj) / k2j) >= 0) &&
+                            (((m - lm) / k3m) >= 0) &&
+                            (((i - li) / k1i) < BN4) &&
+                            (((j - lj) / k2j) < BN2) &&
+                            (((m - lm) / k3m) < BN3))
+                        {
+                            mb = (i - li) / k1i;
+                            jb = (j - lj) / k2j;
+                            ib = k;
+                            nb = (m - lm) / k3m;
+                            B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                        }
+                    }
+                }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] !=val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* ---------------------------------------------ALIGN448*/
+/* ALIGN arrB[][i][j][] WITH arrA[i][j][1][3]
+   compression and replication*/
+void align448()
+{
+/*     parameters for ALIGN arrB[][i][j][]
+                      WITH arrA[k1i*i+li][k2j*j+lj][ln][lm]*/
+    #define AN1 4
+    #define AN2 4
+    #define AN3 4
+    #define AN4 6
+    #define BN1 4
+    #define BN2 4
+    #define BN3 4
+    #define BN4 4
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 0;
+    int k1j = 0, k2j = 1, k3j = 0, k4j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 0, k4n = 0, ln = 1;
+    int k1m = 0, k2m = 0, k3m = 0, k4m = 0, lm = 3;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([][i][j][] with A4[k1i*i+li][k2j*j+lj][ln][lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "align448";
+
+    erri = ER;
+    s = 0;
+
+    #pragma dvm actual(erri, s)
+    #pragma dvm region local(A4, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb, k, l)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    if ((n == ln) && (m == lm))
+                    {
+                        for (k = 0; k < BN1; k++)
+                            for (l = 0; l < BN4; l++)
+                            {
+                                if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                                    ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                                    (((i - li) / k1i) >= 0) &&
+                                    (((j - lj) / k2j) >= 0) &&
+                                    (((i - li) / k1i) < BN2) &&
+                                    (((j - lj) / k2j) < BN3))
+                                {
+                                    ib = k;
+                                    jb = (i - li) / k1i;
+                                    nb = (j - lj) / k2j;
+                                    mb = l;
+                                    B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                                }
+                            }
+                    }
+                }
+
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erri), sum(s))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s = s + B4[i][j][n][m];
+                    if (B4[i][j][n][m] !=val)
+                        if (erri > val) erri = val;
+                }
+
+    }
+    #pragma dvm get_actual(erri, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    if ((erri == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/ALIGN/aligndyn11.cdv

@@ -0,0 +1,422 @@
+/*    ALIGNDYN11
+TESTING align CLAUSE for dynamic arrays*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void align111();
+static void align1111();
+static void align1112();
+static void align112();
+static void align113();
+static void align114();
+static void align115();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF ALIGNDYN11 ===================\n");
+            /* ALIGN arrB[i] WITH arrA[i]  normal*/
+    align111();
+            /* ALIGN arrB[i] WITH arrA[i]  small array*/
+    align1111();
+            /* ALIGN arrB[i] WITH arrA[2*i+3]  small array*/
+    align1112();
+             /* ALIGN arrB[i] WITH arrA[i+4]  shift along i*/
+    align112();
+             /* ALIGN arrB[i] WITH arrA[-i+8] reverse on i*/
+//    align113();
+             /* ALIGN arrB[i] WITH arrA[2*i+8]  stretching along i*/
+    align114();
+             /* ALIGN arrB[] WITH arrA[]*/
+    align115();
+    printf("=== END OF ALIGNDYN11 =====================\n");
+    return 0;
+}
+/* ---------------------------------------------ALIGN111*/
+/* ALIGN arrB[i] WITH arrA[i] normal*/
+void align111()
+{
+/*     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    int AN1 = 8;
+    int BN1 = 8;
+    int k1i = 1;
+    int k2i = 0;
+    int li = 0;
+    char tname[] = "align111 ";
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array
+    int *B1;
+
+    /* create arrays */
+    A1 = malloc(AN1 * sizeof(int));
+    B1 = malloc(BN1 * sizeof(int));
+    #pragma dvm realign(B1[i] with A1[k1i * i + li])
+
+    erri = ER;
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(B1);
+    free(A1);
+}
+/* ---------------------------------------------ALIGN1111*/
+/* ALIGN arrB[i] WITH arrA[i] small array*/
+void align1111()
+{
+/*     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    int AN1 = 5;
+    int BN1 = 2;
+    int k1i = 1;
+    int k2i = 0;
+    int li = 0;
+    char tname[] = "align1111";
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array
+    int *B1;
+
+    /* create arrays */
+    A1 = malloc(AN1 * sizeof(int));
+    B1 = malloc(BN1 * sizeof(int));
+    #pragma dvm realign(B1[i] with A1[k1i * i + li])
+
+    erri = ER;
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(B1);
+    free(A1);
+}
+/* ---------------------------------------------ALIGN1112*/
+/* ALIGN arrB[i] WITH arrA[2*i+1]  small array*/
+void align1112()
+{
+/*     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    int AN1 = 5;
+    int BN1 = 2;
+    int k1i = 2;
+    int k2i = 0;
+    int li = 1;
+    char tname[] = "align1112";
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array
+    int *B1;
+
+    /* create arrays */
+    A1 = malloc(AN1 * sizeof(int));
+    B1 = malloc(BN1 * sizeof(int));
+    #pragma dvm realign(B1[i] with A1[k1i * i + li])
+
+    erri = ER;
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(B1);
+    free(A1);
+}
+/* ---------------------------------------------ALIGN112*/
+/* ALIGN arrB[i] WITH arrA[i+4]  shift along i*/
+void align112()
+{
+/*     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    int AN1 = 8;
+    int BN1 = 4;
+    int k1i = 1;
+    int k2i = 0;
+    int li = 4;
+    char tname[] = "align112 ";
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array
+    int *B1;
+
+    /* create arrays */
+    A1 = malloc(AN1 * sizeof(int));
+    B1 = malloc(BN1 * sizeof(int));
+    #pragma dvm realign(B1[i] with A1[k1i * i + li])
+
+    erri = ER;
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(B1);
+    free(A1);
+}
+/* ---------------------------------------------ALIGN113*/
+/* ALIGN arrB[i] WITH arrA[-i+8] reverse on i*/
+void align113()
+{
+/*     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    int AN1 = 8;
+    int BN1 = 8;
+    int k1i = -1;
+    int k2i = 0;
+    int li = 8;
+    char tname[] = "align113 ";
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array
+    int *B1;
+
+    /* create arrays */
+    A1 = malloc(AN1 * sizeof(int));
+    B1 = malloc(BN1 * sizeof(int));
+    #pragma dvm realign(B1[i] with A1[k1i * i + li])
+
+    erri = ER;
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(B1);
+    free(A1);
+}
+/* ---------------------------------------------ALIGN114*/
+/* ALIGN arrB[i] WITH arrA[2*i+8]  stretching along i*/
+void align114()
+{
+/*     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]  */
+    int AN1 = 24;
+    int BN1 = 8;
+    int k1i = 2;
+    int k2i = 0;
+    int li = 8;
+    char tname[] = "align114 ";
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array
+    int *B1;
+
+    /* create arrays */
+    A1 = malloc(AN1 * sizeof(int));
+    B1 = malloc(BN1 * sizeof(int));
+    #pragma dvm realign(B1[i] with A1[k1i * i + li])
+
+    erri = ER;
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] = ib;
+        }
+    }
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erri)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i)
+            if (erri > i) erri = i;
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+            if (erri > i) erri = i;
+    }
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(B1);
+    free(A1);
+}
+/* ---------------------------------------------ALIGN115*/
+/* ALIGN arrB[] WITH arrA[]*/
+void align115()
+{
+/*    parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]*/
+    int AN1 = 24;
+    int BN1 = 8;
+    int k1i = 0;
+    int k2i = 0;
+    int li  = 0;
+    char tname[] = "align115 ";
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array
+    int (*B1);
+
+    A1 = malloc(AN1 * sizeof(int));
+    B1 = malloc(BN1 * sizeof(int));
+    #pragma dvm realign(B1[] with A1[])
+
+    erri = ER;
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = i;
+    #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), private(j)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < BN1; j++)
+        {
+            if (B1[j] != j)
+                if (erri > j) erri = j;
+        }
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(B1);
+    free(A1);
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR/distr1.cdv

@@ -0,0 +1,297 @@
+/*    DISTR1
+TESTING distribute and redistribute CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distr11();
+static void distr12();
+static void distr13();
+static void distr14();
+static void distr21();
+static void distr22();
+static void distr23();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTR1 ===================\n");
+            /* DISTRIBUTE arrA1[BLOCK] REDISTRIBUTE arrA1[*]*/
+    distr11();
+            /* DISTRIBUTE arrA1[*] REDISTRIBUTE arrA1[BLOCK]*/
+    distr12();
+            /* DISTRIBUTE arrA1[BLOCK] REDISTRIBUTE arrA1[*] small array*/
+    distr13();
+             /* DISTRIBUTE arrA1[*] REDISTRIBUTE arrA1[BLOCK] small array*/
+    distr14();
+             /* DISTRIBUTE arrA2[BLOCK][*] REDISTRIBUTE arrA2[*][BLOCK]*/
+    distr21();
+             /* DISTRIBUTE arrA2[*][BLOCK] REDISTRIBUTE arrA2[*][*]*/
+    distr22();
+             /* DISTRIBUTE arrA2[*][*] REDISTRIBUTE arrA2[*][BLOCK]*/
+    distr23();
+    printf("=== END OF DISTR1 =====================\n");
+    return 0;
+}
+/* ---------------------------------------------DISTR11*/
+            /* DISTRIBUTE arrA1[BLOCK] REDISTRIBUTE arrA1[*]*/
+void distr11()
+{
+    #define AN1 8
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    char tname[] = "distr11";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+}
+/* ---------------------------------------------DISTR12*/
+            /* DISTRIBUTE arrA1[*] REDISTRIBUTE arrA1[BLOCK]*/
+void distr12()
+{
+    #define AN1 8
+
+    #pragma dvm array distribute[*]
+    float A1[AN1];
+    char tname[] = "distr12";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+}
+/* ---------------------------------------------DISTR13*/
+            /* DISTRIBUTE arrA1[BLOCK] REDISTRIBUTE arrA1[*] small array*/
+void distr13()
+{
+    #define AN1 5
+
+    #pragma dvm array distribute[block]
+    double A1[AN1];
+    char tname[] = "distr13";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+}
+/* ---------------------------------------------DISTR14*/
+             /* DISTRIBUTE arrA1[*] REDISTRIBUTE arrA1[BLOCK] small array*/
+void distr14()
+{
+    #define AN1 5
+
+    #pragma dvm array distribute[*]
+    long A1[AN1];
+    char tname[] = "distr14";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+}
+/* ---------------------------------------------DISTR21*/
+             /* DISTRIBUTE arrA2[BLOCK][*] REDISTRIBUTE arrA2[*][BLOCK]*/
+void distr21()
+{
+    #define AN1 8
+    #define AN2 8
+
+    #pragma dvm array distribute[block][*]
+    int A2[AN1][AN2];
+    char tname[] = "distr21";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+    #pragma dvm redistribute(A2[*][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+}
+/* ---------------------------------------------DISTR22*/
+             /* DISTRIBUTE arrA2[*][BLOCK] REDISTRIBUTE arrA2[*][*]*/
+void distr22()
+{
+    #define AN1 8
+    #define AN2 8
+
+    #pragma dvm array distribute[*][block]
+    float A2[AN1][AN2];
+    char tname[] = "distr22";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+    #pragma dvm redistribute(A2[*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+}
+/* ---------------------------------------------DISTR23*/
+             /* DISTRIBUTE arrA2[*][*] REDISTRIBUTE arrA2[*][BLOCK]*/
+void distr23()
+{
+    #define AN1 8
+    #define AN2 8
+
+    #pragma dvm array distribute[*][*]
+    double A2[AN1][AN2];
+    char tname[] = "distr23";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+    #pragma dvm redistribute(A2[*][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR/distr2.cdv

@@ -0,0 +1,257 @@
+/*    DISTR2
+TESTING distribute and redistribute CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distr24();
+static void distr32();
+static void distr33();
+static void distr41();
+static void distr42();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, n, m, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTR2 ===================\n");
+    /* DISTRIBUTE arrA2[BLOCK][BLOCK]  REDISTRIBUTE arrA2[*][*]*/
+    distr24();
+    /* DISTRIBUTE  arrA3[BLOCK][*][BLOCK] REDISTRIBUTE arrA3[*][BLOCK][BLOCK] */
+    distr32();
+    /* DISTRIBUTE  arrA3[BLOCK][*][BLOCK] REDISTRIBUTE arrA3[*][BLOCK][*] */
+    distr33();
+    /* DISTRIBUTE arrA4[*][*][BLOCK][BLOCK] REDISTRIBUTE arrA4[*][*][*][*]*/
+    distr41();
+    /* DISTRIBUTE arrA4[BLOCK][*][BLOCK][*] REDISTRIBUTE arrA4[*][BLOCK][BLOCK][*]*/
+    distr42();
+    printf("=== END OF DISTR2 =====================\n");
+    return 0;
+}
+/* ---------------------------------------------DISTR24*/
+/*  DISTRIBUTE arrA2[BLOCK][BLOCK] REDISTRIBUTE arrA2[*][*]*/
+void distr24()
+{
+    #define AN1 8
+    #define AN2 8
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    char tname[] = "distr24";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+    #pragma dvm redistribute(A2[*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+}
+/* ---------------------------------------------DISTR32*/
+/* DISTRIBUTE arrA3[BLOCK][*][BLOCK] REDISTRIBUTE arrA3[*][BLOCK][BLOCK]*/
+void distr32()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+
+    #pragma dvm array distribute[block][*][block]
+    float A3[AN1][AN2][AN3];
+    char tname[] = "distr32";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n] on A3[i][j][n]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    A3[i][j][n] = i * NL / 10 + j * NL / 100 + n;
+    }
+    #pragma dvm redistribute(A3[*][block][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n] on A3[i][j][n]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    if (A3[i][j][n] != i * NL / 10 + j * NL / 100 + n)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+/* ---------------------------------------------DISTR33*/
+/* DISTRIBUTE  arrA3[BLOCK][*][ BLOCK] REDISTRIBUTE arrA3[*][BLOCK][*] */
+void distr33()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+
+    #pragma dvm array distribute[block][*][block]
+    double A3[AN1][AN2][AN3];
+    char tname[] = "distr33";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n] on A3[i][j][n]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    A3[i][j][n] = i * NL / 10 + j * NL / 100 + n;
+    }
+    #pragma dvm redistribute(A3[*][block][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n] on A3[i][j][n]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    if (A3[i][j][n] != i * NL / 10 + j * NL / 100 + n)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+/* ---------------------------------------------DISTR41*/
+/* DISTRIBUTE arrA4[*][*][BLOCK][BLOCK] REDISTRIBUTE arrA4[*][*][*][*]*/
+void distr41()
+{
+    #define AN1 5
+    #define AN2 5
+    #define AN3 5
+    #define AN4 5
+
+    #pragma dvm array distribute[*][*][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    char tname[] = "distr41";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    }
+    #pragma dvm redistribute(A4[*][*][*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        if (A4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                            erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+/* ---------------------------------------------DISTR42*/
+/* DISTRIBUTE arrA4[BLOCK][*][BLOCK][*] REDISTRIBUTE arrA4[*][BLOCK][BLOCK][*]*/
+void distr42()
+{
+    #define AN1 5
+    #define AN2 5
+    #define AN3 5
+    #define AN4 5
+
+    #pragma dvm array distribute[block][*][block][*]
+    float A4[AN1][AN2][AN3][AN4];
+    char tname[] = "distr42";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    }
+    #pragma dvm redistribute(A4[*][block][block][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        if (A4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                            erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR/distr3.cdv

@@ -0,0 +1,125 @@
+/*    DISTR3
+TESTING distribute and redistribute CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distr31();
+static void distr43();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, n, m, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTR3 ===================\n");
+    /* DISTRIBUTE  arrA3[BLOCK][BLOCK][BLOCK] REDISTRIBUTE arrA3[*][*][*]*/
+    distr31();
+    /* DISTRIBUTE arrA4[BLOCK][*][BLOCK][BLOCK] REDISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][*]*/
+    distr43();
+    printf("=== END OF DISTR3 =====================\n");
+    return 0;
+}
+/* ---------------------------------------------DISTR31*/
+/* DISTRIBUTE  arrA3[BLOCK][BLOCK][BLOCK] REDISTRIBUTE arrA3[*][*][*]*/
+void distr31()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    char tname[] = "distr31";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n] on A3[i][j][n]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    A3[i][j][n] = i * NL / 10 + j * NL / 100 + n;
+    }
+    #pragma dvm redistribute(A3[*][*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n] on A3[i][j][n]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    if (A3[i][j][n] != i * NL / 10 + j * NL / 100 + n)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+/* ---------------------------------------------DISTR43*/
+/* DISTRIBUTE arrA4[BLOCK][*][BLOCK][BLOCK] REDISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][*]*/
+void distr43()
+{
+    #define AN1 5
+    #define AN2 5
+    #define AN3 5
+    #define AN4 5
+
+    #pragma dvm array distribute[block][*][block][block]
+    double A4[AN1][AN2][AN3][AN4];
+    char tname[] = "distr43";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    }
+    #pragma dvm redistribute(A4[block][block][block][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        if (A4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                            erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR/distr4.cdv

@@ -0,0 +1,229 @@
+/*    DISTR4
+TESTING distribute and redistribute CLAUSE*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distr44();
+static void distr45();
+static void distr46();
+static void distr47();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, n, m, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTR4 ===================\n");
+    /* DISTRIBUTE arrA4[*][*][*][*] REDISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][BLOCK]*/
+    distr44();
+    /* DISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][BLOCK] REDISTRIBUTE arrA4[*][*][*][*]*/
+    distr45();
+    /* DISTRIBUTE arrA4[*][*][*][*] REDISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][BLOCK]
+     small array*/
+    distr46();
+    /* DISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][BLOCK] REDISTRIBUTE arrA4[*][*][*][*]
+     small array*/
+    distr47();
+    printf("=== END OF DISTR4 =====================\n");
+    return 0;
+}
+/* ---------------------------------------------DISTR44*/
+/* DISTRIBUTE arrA4[*][*][*][*] REDISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][BLOCK]*/
+void distr44()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    #define AN4 8
+
+    #pragma dvm array distribute[*][*][*][*]
+    int A4[AN1][AN2][AN3][AN4];
+    char tname[] = "distr44";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    }
+    #pragma dvm redistribute(A4[block][block][block][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        if (A4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                            erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+/* ---------------------------------------------DISTR45*/
+/* DISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][BLOCK] REDISTRIBUTE arrA4[*][*][*][*]*/
+void distr45()
+{
+    #define AN1 5
+    #define AN2 5
+    #define AN3 5
+    #define AN4 5
+
+    #pragma dvm array distribute[block][block][block][block]
+    float A4[AN1][AN2][AN3][AN4];
+    char tname[] = "distr45";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    }
+    #pragma dvm redistribute(A4[*][*][*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        if (A4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                            erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+/* ---------------------------------------------DISTR46*/
+/* DISTRIBUTE arrA4[*][*][*][*] REDISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][BLOCK]
+   small array*/
+void distr46()
+{
+    #define AN1 5
+    #define AN2 4
+    #define AN3 3
+    #define AN4 2
+
+    #pragma dvm array distribute[*][*][*][*]
+    double A4[AN1][AN2][AN3][AN4];
+    char tname[] = "distr46";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    }
+    #pragma dvm redistribute(A4[block][block][block][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        if (A4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                            erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+/* ---------------------------------------------DISTR47*/
+/* DISTRIBUTE arrA4[BLOCK][BLOCK][BLOCK][BLOCK] REDISTRIBUTE arrA4[*][*][*][*]
+   small array*/
+void distr47()
+{
+    #define AN1 1
+    #define AN2 2
+    #define AN3 3
+    #define AN4 4
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    char tname[] = "distr47";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    }
+    #pragma dvm redistribute(A4[*][*][*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (n = 0; n < AN3; n++)
+                    for (m = 0; m < AN4; m++)
+                        if (A4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                            erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_GEN/distrgen1.cdv

@@ -0,0 +1,386 @@
+/*    DISTRGEN1
+TESTING distribute and redistribute CLAUSE
+for arrays distributed with GEN-block*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+#ifndef _DVMH
+#define dvmh_get_num_procs(X) 1
+#endif
+
+static void distrg10();
+static void distrg11();
+static void distrg12();
+static void distrg13();
+static void distrg14();
+static void distrg15();
+static void distrg161();
+static void distrg162();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRGEN1 ===================\n");
+    /* DISTRIBUTE arrA1[BLOCK] REDISTRIBUTE arrA1[GENBLOCK]*/
+    distrg10();
+
+    /* DISTRIBUTE arrA1[GENBLOCK] REDISTRIBUTE arrA1[BLOCK]*/
+    distrg11();
+
+    /* DISTRIBUTE arrA1[GENBLOCK] REDISTRIBUTE arrA1[*]*/
+    distrg12();
+
+    /* DISTRIBUTE arrA1[BLOCK] REDISTRIBUTE arrA1[*]*/
+    distrg13();
+
+    /* DISTRIBUTE arrA1[*] REDISTRIBUTE arrA1[BLOCK]*/
+    distrg14();
+
+    /* DISTRIBUTE arrA1[*] REDISTRIBUTE arrA1[GENBLOCK]*/
+    distrg15();
+
+    /* DISTRIBUTE arrA1[GENBLOCK] REDISTRIBUTE arrA1[GENBLOCK]
+       with 0 in BS.1*/
+    distrg161();
+
+    /* DISTRIBUTE arrA1[GENBLOCK] REDISTRIBUTE arrA1[GENBLOCK]
+       with 0 in BS.2*/
+    distrg162();
+
+    printf("=== END OF DISTRGEN1 =====================\n");
+    return 0;
+}
+
+static int myRand() {
+    const unsigned a = 1103515245U;
+    const unsigned c = 12345U;
+    const unsigned m = ((unsigned)RAND_MAX) + 1U;
+    static unsigned prev = 5;
+    prev = (a * prev + c) % m;
+    return prev;
+}
+
+static void genBlocksAxis(const int procCount, const int weight, const int withoutZero, int **blocks) {
+    *blocks = (int *)malloc(procCount * sizeof(int));
+    int restWeight = weight, i, zeroind = -1;
+    if (!withoutZero && procCount != 1)
+        zeroind = myRand() % (procCount - 1);
+    for (i = 0; i < (procCount - 1); i++) {
+        if (i == zeroind)
+            (*blocks)[i] = 0;
+        else
+            (*blocks)[i] = 1 * withoutZero + myRand() % (restWeight - (procCount - (i + 1)));
+        restWeight -= (*blocks)[i];
+    }
+    (*blocks)[i] = restWeight;
+}
+
+/* ---------------------------------------------DISTR10*/
+/* DISTRIBUTE arrA1[BLOCK] REDISTRIBUTE arrA1[GENBLOCK]*/
+void distrg10()
+{
+    #define AN1 8
+    int* BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS);
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    char tname[] = "distrg10";
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[genblock(BS)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR11*/
+/* DISTRIBUTE arrA1[GENBLOCK] REDISTRIBUTE arrA1[BLOCK]*/
+void distrg11()
+{
+    #define AN1 8
+    int *BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS);
+    #pragma dvm array distribute[genblock(BS)]
+    int A1[AN1];
+    char tname[] = "distrg11";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR12*/
+/* DISTRIBUTE arrA1[GENBLOCK] REDISTRIBUTE arrA1[*]*/
+void distrg12()
+{
+    #define AN1 8
+    int *BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS);
+    #pragma dvm array distribute[genblock(BS)]
+    int A1[AN1];
+    char tname[] = "distrg12";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR13*/
+/* DISTRIBUTE arrA1[BLOCK] REDISTRIBUTE arrA1[*]*/
+void distrg13()
+{
+    #define AN1 8
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    char tname[] = "distrg13";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR14*/
+/* DISTRIBUTE arrA1[*] REDISTRIBUTE arrA1[BLOCK]*/
+void distrg14()
+{
+    #define AN1 8
+
+    #pragma dvm array distribute[*]
+    int A1[AN1];
+    char tname[] = "distrg14";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR15*/
+/* DISTRIBUTE arrA1[*] REDISTRIBUTE arrA1[GENBLOCK]*/
+void distrg15()
+{
+    #define AN1 8
+    int *BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS);
+    #pragma dvm array distribute[*]
+    int A1[AN1];
+    char tname[] = "distrg15";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[genblock(BS)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR161*/
+/* DISTRIBUTE arrA1[GENBLOCK] REDISTRIBUTE arrA1[GENBLOCK]
+   wtih 0 in BS.1*/
+/*{0, 8} - works, {8, 0} - cycle*/
+void distrg161()
+{
+    #define AN1 8
+    int *BS1, *BS2;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS2);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 0, &BS1);
+    #pragma dvm array distribute[genblock(BS1)]
+    int A1[AN1];
+    char tname[] = "distrg161";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[genblock(BS2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1);
+    free(BS2);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR162*/
+/* DISTRIBUTE arrA1[GENBLOCK] REDISTRIBUTE arrA1[GENBLOCK]
+   wtih 0 in BS.2*/
+void distrg162()
+{
+    #define AN1 8
+    int *BS1, *BS2;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 0, &BS2);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1);
+    #pragma dvm array distribute[genblock(BS1)]
+    int A1[AN1];
+    char tname[] = "distrg162";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[genblock(BS2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1);
+    free(BS2);
+    #undef AN1
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_GEN/distrgen2.cdv

@@ -0,0 +1,648 @@
+/*    DISTRGEN2
+TESTING distribute and redistribute CLAUSE
+for arrays distributed with GEN-block*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+#ifndef _DVMH
+#define dvmh_get_num_procs(X) 1
+#endif
+
+static void distrg21();
+static void distrg22();
+static void distrg23();
+static void distrg24();
+static void distrg25();
+static void distrg26();
+static void distrg261();
+static void distrg27();
+static void distrg28();
+static void distrg29();
+static void distrg210();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRGEN2 ===================\n");
+    /* DISTRIBUTE arrA2[BLOCK][*] REDISTRIBUTE arrA2[*][GENBLOCK]*/
+    distrg21();
+
+    /* DISTRIBUTE arrA2[*][BLOCK] REDISTRIBUTE arrA2[GENBLOCK][*]*/
+    distrg22();
+
+    /* DISTRIBUTE arrA2[*][GENBLOCK] REDISTRIBUTE arrA2[*][*]*/
+    distrg23();
+
+    /* DISTRIBUTE arrA2[*][*] REDISTRIBUTE arrA2[GENBLOCK][*]*/
+    distrg24();
+
+    /* DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+              REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK] other blocks*/
+    distrg25();
+
+    /* DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+                             REDISTRIBUTE arrA2[BLOCK][BLOCK]
+                             REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]*/
+    distrg26();
+
+    /* DISTRIBUTE arrA2[GEN_BLOCK][BLOCK]
+                         REDISTRIBUTE arrA2[BLOCK][GEN_BLOCK]
+                         REDISTRIBUTE arrA2[GEN_BLOCK][BLOCK]*/
+    distrg27();
+
+    /* DISTRIBUTE arrA2[BLOCK][GEN_BLOCK]
+                         REDISTRIBUTE arrA2[BLOCK][BLOCK]
+                         REDISTRIBUTE arrA2[GEN_BLOCK][BLOCK]*/
+    distrg28();
+
+    /* DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+                         REDISTRIBUTE arrA2[*][*]
+                         REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]*/
+    distrg29();
+
+    /* DISTRIBUTE arrA2[GEN_BLOCK][*]
+                         REDISTRIBUTE arrA2[*][*]
+                         REDISTRIBUTE arrA2[*][GEN_BLOCK]*/
+    distrg210();
+
+    printf("=== END OF DISTRGEN2 =====================\n");
+    return 0;
+}
+
+static int myRand() {
+    const unsigned a = 1103515245U;
+    const unsigned c = 12345U;
+    const unsigned m = ((unsigned)RAND_MAX) + 1U;
+    static unsigned prev = 5;
+    prev = (a * prev + c) % m;
+    return prev;
+}
+
+static void genBlocksAxis(const int procCount, const int weight, const int withoutZero, int **blocks) {
+    *blocks = (int *)malloc(procCount * sizeof(int));
+    int restWeight = weight, i, zeroind = -1;
+    if (!withoutZero && procCount != 1)
+        zeroind = myRand() % (procCount - 1);
+    for (i = 0; i < (procCount - 1); i++) {
+        if (i == zeroind)
+            (*blocks)[i] = 0;
+        else
+            (*blocks)[i] = 1 * withoutZero + myRand() % (restWeight - (procCount - (i + 1)));
+        restWeight -= (*blocks)[i];
+    }
+    (*blocks)[i] = restWeight;
+}
+/* ---------------------------------------------DISTR21*/
+/* DISTRIBUTE arrA2[BLOCK][*] REDISTRIBUTE arrA2[*][GENBLOCK]*/
+void distrg21()
+{
+    #define AN1 8
+    #define AN2 8
+    int *BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN2, 1, &BS);
+    #pragma dvm array distribute[block][*]
+    int A1[AN1][AN2];
+    char tname[] = "distrg21";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A1[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A1[i][j] = i*NL + j;
+    }
+    #pragma dvm redistribute(A1[*][genblock(BS)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A1[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A1[i][j] != i*NL + j)
+                    erri = Min(erri, i*NL/10 + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR22*/
+/* DISTRIBUTE arrA2[*][BLOCK] REDISTRIBUTE arrA2[GENBLOCK][*]*/
+void distrg22()
+{
+    #define AN1 8
+    #define AN2 8
+    int *BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS);
+    #pragma dvm array distribute[*][block]
+    int A1[AN1][AN2];
+    char tname[] = "distrg22";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A1[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A1[i][j] = i*NL + j;
+    }
+    #pragma dvm redistribute(A1[genblock(BS)][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A1[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A1[i][j] != i*NL + j)
+                    erri = Min(erri, i*NL/10 + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR23*/
+/* DISTRIBUTE arrA2[*][GENBLOCK] REDISTRIBUTE arrA2[*][*]*/
+void distrg23()
+{
+    #define AN1 8
+    #define AN2 8
+    int *BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN2, 1, &BS);
+    #pragma dvm array distribute[*][genblock(BS)]
+    int A1[AN1][AN2];
+    char tname[] = "distrg23";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A1[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A1[i][j] = i*NL + j;
+    }
+    #pragma dvm redistribute(A1[*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A1[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A1[i][j] != i*NL + j)
+                    erri = Min(erri, i*NL/10 + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR24*/
+/* DISTRIBUTE arrA2[*][*] REDISTRIBUTE arrA2[GENBLOCK][*]*/
+void distrg24()
+{
+    #define AN1 8
+    #define AN2 8
+    int *BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS);
+    #pragma dvm array distribute[*][*]
+    int A1[AN1][AN2];
+    char tname[] = "distrg24";
+
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A1[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A1[i][j] = i*NL + j;
+    }
+    #pragma dvm redistribute(A1[genblock(BS)][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A1[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A1[i][j] != i*NL + j)
+                    erri = Min(erri, i*NL/10 + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR25*/
+/* DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+              REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK] other blocks*/
+void distrg25()
+{
+    #define AN1 10
+    #define AN2 12
+    int *BS1i, *BS1j, *BS2i, *BS2j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS2i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS2j);
+    //int BS1i[2] = {5, 5}, BS1j[2] = {7, 5};
+    //int BS2i[2] = {6, 4}, BS2j[2] = {5, 7};
+    #pragma dvm array distribute[genblock(BS1i)][genblock(BS1j)]
+    int A2[AN1][AN2];
+    char tname[] = "distrg25";
+
+    erri = ER;
+
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            A2[i][j] = 1;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += i*NL+j;
+    }
+
+    #pragma dvm redistribute(A2[genblock(BS2i)][genblock(BS2j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i*NL+j + 1)
+                    erri = Min(erri, i*NL/10+j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(BS2i);
+    free(BS2j);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR26*/
+/* DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+                             REDISTRIBUTE arrA2[BLOCK][BLOCK]
+                             REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]*/
+void distrg26()
+{
+    #define AN1 10
+    #define AN2 12
+    int *BS1i, *BS1j, *BS2i, *BS2j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS2i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS2j);
+    #pragma dvm array distribute[genblock(BS1i)][genblock(BS1j)]
+    int A2[AN1][AN2];
+    char tname[] = "distrg26";
+    erri = ER;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = 1;
+    }
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += i*NL+j;
+    }
+    #pragma dvm redistribute(A2[block][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[genblock(BS2i)][genblock(BS2j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i*NL+j + 3)
+                    erri = Min(erri, i*NL/10 + j + 3);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(BS2i);
+    free(BS2j);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR27*/
+ /* DISTRIBUTE arrA2[GEN_BLOCK][BLOCK]
+                         REDISTRIBUTE arrA2[BLOCK][GEN_BLOCK]
+                         REDISTRIBUTE arrA2[GEN_BLOCK][BLOCK]*/
+
+void distrg27()
+{
+    #define AN1 10
+    #define AN2 12
+    int *BS1i, *BS2j, *BS3i;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS3i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS2j);
+    #pragma dvm array distribute[genblock(BS1i)][block]
+    int A2[AN1][AN2];
+    char tname[] = "distrg27";
+
+    erri = ER;
+
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            A2[i][j] = 1;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += i*NL+j;
+    }
+    #pragma dvm redistribute(A2[block][genblock(BS2j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[genblock(BS3i)][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i*NL+j + 3)
+                    erri = Min(erri, i*NL/10+j + 3);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS3i);
+    free(BS2j);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR28*/
+/* DISTRIBUTE arrA2[BLOCK][GEN_BLOCK]
+                         REDISTRIBUTE arrA2[BLOCK][BLOCK]
+                         REDISTRIBUTE arrA2[GEN_BLOCK][BLOCK]*/
+void distrg28()
+{
+    #define AN1 10
+    #define AN2 12
+    int *BS1j, *BS2i;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS2i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    #pragma dvm array distribute[block][genblock(BS1j)]
+    int A2[AN1][AN2];
+    char tname[] = "distrg28";
+
+    erri = ER;
+
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            A2[i][j] = 1;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += i*NL+j;
+    }
+    #pragma dvm redistribute(A2[block][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+
+    #pragma dvm redistribute(A2[genblock(BS2i)][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i*NL+j + 3)
+                    erri = Min(erri, i*NL/10+j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS2i);
+    free(BS1j);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR29*/
+/* DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+                         REDISTRIBUTE arrA2[*][*]
+                         REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]*/
+void distrg29()
+{
+    #define AN1 10
+    #define AN2 12
+    int *BS1i, *BS1j, *BS2i, *BS2j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS2i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS2j);
+    #pragma dvm array distribute[genblock(BS1i)][genblock(BS1j)]
+    int A2[AN1][AN2];
+    char tname[] = "distrg29";
+
+    erri = ER;
+
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            A2[i][j] = 1;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += i*NL+j;
+    }
+    #pragma dvm redistribute(A2[*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[genblock(BS2i)][genblock(BS2j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i*NL+j + 3)
+                    erri = Min(erri, i*NL/10+j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(BS2i);
+    free(BS2j);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR210*/
+/* DISTRIBUTE arrA2[GEN_BLOCK][*]
+                         REDISTRIBUTE arrA2[*][*]
+                         REDISTRIBUTE arrA2[*][GEN_BLOCK]*/
+void distrg210()
+{
+    #define AN1 10
+    #define AN2 12
+    int *BS1i, *BS2i;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(1), AN2, 1, &BS2i);
+    #pragma dvm array distribute[genblock(BS1i)][*]
+    int A2[AN1][AN2];
+    char tname[] = "distrg210";
+
+    erri = ER;
+
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            A2[i][j] = 1;
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += i*NL+j;
+    }
+    #pragma dvm redistribute(A2[*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[*][genblock(BS2i)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j])
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i*NL+j + 3)
+                    erri = Min(erri, i*NL/10+j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS2i);
+    #undef AN1
+    #undef AN2
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_MIX/deldistr1.cdv

@@ -0,0 +1,217 @@
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+#ifndef _DVMH
+#define dvmh_get_num_procs(X) 1
+#endif
+
+static void distr11();
+static void distr12();
+static void distr13();
+static void distr14();
+static void distr15();
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+static int ER = 10000;
+static int erri, i, j, k;
+
+int main(int an, char **as) {
+    printf("=== START OF DELDISTR1 ===================\n");
+    distr11();
+    distr12();
+    distr13();
+    distr14();
+    distr15();
+    printf("=== END OF DELDISTR1 ===================\n");
+    return 0;
+}
+
+static int myRand() {
+    const unsigned a = 1103515245U;
+    const unsigned c = 12345U;
+    const unsigned m = ((unsigned)RAND_MAX) + 1U;
+    static unsigned prev = 5;
+    prev = (a * prev + c) % m;
+    return prev;
+}
+
+static void genBlocksAxis(const int procCount, const int weight, const int withoutZero, int **blocks) {
+    *blocks = (int *)malloc(procCount * sizeof(int));
+    int restWeight = weight, i, zeroind = -1;
+    if (!withoutZero && procCount != 1)
+        zeroind = myRand() % (procCount - 1);
+    for (i = 0; i < (procCount - 1); i++) {
+        if (i == zeroind)
+            (*blocks)[i] = 0;
+        else
+            (*blocks)[i] = 1 * withoutZero + myRand() % (restWeight - (procCount - (i + 1)));
+        restWeight -= (*blocks)[i];
+    }
+    (*blocks)[i] = restWeight;
+}
+
+void distr11()
+{
+    #define AN1 8
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distr11";
+    erri = ER;
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+void distr12()
+{
+    #define AN1 8
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distr12";
+    erri = ER;
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++) {
+            if (A1[i] != i)
+                erri = Min(erri, i);
+        }
+    }
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+void distr13()
+{
+    #define AN1 8
+    int* BS1;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1);
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distr13";
+    erri = ER;
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[genblock(BS1)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1);
+    free(A1);
+    #undef AN1
+}
+void distr14()
+{
+    #define AN1 8
+    double wb1[8] = {1.0, 2., 2., 3.0, 1., 1., 1.5, 2.};
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distr14";
+    erri = ER;
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[wgtblock(wb1, 8)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+void distr15()
+{
+    #define AN1 8
+    int m1 = 4;
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distr15";
+    erri = ER;
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[multblock(m1)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+void ansyes(const char name[]) {
+    printf("%s  -  complete\n", name);
+}
+void ansno(const char name[]) {
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_MIX/distrmix1.cdv

@@ -0,0 +1,398 @@
+/*    DISTRMIX1
+Testing DISTRIBUTE and REDISTRIBUTE directive
+            GEN_BLOCK, WGT_BLOCK, MULT_BLOCK distributions
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+#ifndef _DVMH
+#define dvmh_get_num_procs(X) 1
+#endif
+
+static void distrmix11();
+static void distrmix12();
+static void distrmix13();
+static void distrmix14();
+static void distrmix15();
+static void distrmix16();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, errib, i, j, k, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRMIX1 ===================\n");
+    /* 11  DISTRIBUTE arrA1[MULT_BLOCK]
+                     REDISTRIBUTE arrA1[WGT_BLOCK]
+                     REDISTRIBUTE arrA1[MULT_BLOCK]*/
+    distrmix11();
+
+   /* DISTRIBUTE arrA3[GEN_BLOCK][GEN_BLOCK][GEN_BLOCK]
+                REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK][GEN_BLOCK] other blocks*/
+    distrmix12();
+    /* DISTRIBUTE arrA3[GEN_BLOCK][GEN_BLOCK][GEN_BLOCK]
+                REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK][GEN_BLOCK] other blocks*/
+    distrmix13();
+    /* DISTRIBUTE arrA3[GEN_BLOCK][GEN_BLOCK][GEN_BLOCK]
+                REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK][GEN_BLOCK] other blocks*/
+    distrmix14();
+    /* DISTRIBUTE arrA3[GEN_BLOCK][GEN_BLOCK][GEN_BLOCK]
+                REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK][GEN_BLOCK] other blocks*/
+    distrmix15();
+    /* DISTRIBUTE arrA3[GEN_BLOCK][GEN_BLOCK][GEN_BLOCK]
+                REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK][GEN_BLOCK] other blocks*/
+    distrmix16();
+
+    printf("=== END OF DISTRMIX1 =====================\n");
+    return 0;
+}
+
+static int myRand() {
+    const unsigned a = 1103515245U;
+    const unsigned c = 12345U;
+    const unsigned m = ((unsigned)RAND_MAX) + 1U;
+    static unsigned prev = 5;
+    prev = (a * prev + c) % m;
+    return prev;
+}
+
+static void genBlocksAxis(const int procCount, const int weight, const int withoutZero, int **blocks) {
+    *blocks = (int *)malloc(procCount * sizeof(int));
+    int restWeight = weight, i, zeroind = -1;
+    if (!withoutZero && procCount > 1)
+        zeroind = myRand() % (procCount - 1);
+    for (i = 0; i < (procCount - 1); i++) {
+        if (i == zeroind)
+            (*blocks)[i] = 0;
+        else
+            (*blocks)[i] = 1 * withoutZero + myRand() % (restWeight - (procCount - (i + 1)));
+        restWeight -= (*blocks)[i];
+    }
+    (*blocks)[i] = restWeight;
+}
+
+/* ---------------------------------------------DISTR11*/
+/* 11  DISTRIBUTE arrA1[MULT_BLOCK]
+                     REDISTRIBUTE arrA1[WGT_BLOCK]
+                     REDISTRIBUTE arrA1[MULT_BLOCK]*/
+void distrmix11()
+{
+    #define AN1 64
+    int m1 = 4, m2 = 2;
+    double wb[7] = {2.1, 4.6, 3., 2.0, 1.5, 2., 3.1};
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrmix11";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[multblock(m1)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[wgtblock(wb, 7)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] += 1;
+    }
+    #pragma dvm redistribute(A1[multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i + 1)
+                erri = Min(erri, i + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR12*/
+/* DISTRIBUTE arrA1[WGT_BLOCK]
+                     REDISTRIBUTE arrA1[MULT_BLOCK]
+                     REDISTRIBUTE arrA1[WGT_BLOCK]  */
+void distrmix12()
+{
+    #define AN1 75
+    int m1 = 15;
+    double wb1[6] = {3.1, 1.6, 2., 3.0, 0.5, 2.};
+    double wb2[8] = {1.5, 2.1, 2.6, 4.2, 2.5, 3.5, 1., 2.1};
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrmix12";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[wgtblock(wb1, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[multblock(m1)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] += 1;
+    }
+    #pragma dvm redistribute(A1[wgtblock(wb2, 8)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i + 1)
+                erri = Min(erri, i + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR13*/
+/* DISTRIBUTE arrA1[MULT_BLOCK]
+                     REDISTRIBUTE arrA1[GEN_BLOCK]
+                     REDISTRIBUTE arrA1[MULT_BLOCK]  */
+void distrmix13()
+{
+    #define AN1 30
+    int m1 = 5, m2 = 3;
+    int* BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS);
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrmix13";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[multblock(m1)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[genblock(BS)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] += 1;
+    }
+    #pragma dvm redistribute(A1[multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i + 1)
+                erri = Min(erri, i + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR14*/
+/* DISTRIBUTE arrA1[GEN_BLOCK]
+                     REDISTRIBUTE arrA1[MULT_BLOCK]
+                     REDISTRIBUTE arrA1[GEN_BLOCK] */
+void distrmix14()
+{
+    #define AN1 35
+    int m1 = 7;
+    int* BS1, * BS2;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS2);
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrmix14";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[genblock(BS1)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[multblock(m1)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] += 1;
+    }
+    #pragma dvm redistribute(A1[genblock(BS2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i + 1)
+                erri = Min(erri, i + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1);
+    free(BS2);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR15*/
+/* DISTRIBUTE arrA1[WGT_BLOCK]
+                     REDISTRIBUTE arrA1[GEN_BLOCK]
+                     REDISTRIBUTE arrA1[WGT_BLOCK]  */
+void distrmix15()
+{
+    #define AN1 10
+    double wb1[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    double wb2[5] = {2.0, 1., 2., 2.0, 2.};
+    int* BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS);
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrmix15";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[wgtblock(wb1, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[genblock(BS)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] += 1;
+    }
+    #pragma dvm redistribute(A1[wgtblock(wb2, 5)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i + 1)
+                erri = Min(erri, i + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR16*/
+/* DISTRIBUTE arrA1[GEN_BLOCK]
+                     REDISTRIBUTE arrA1[WGT_BLOCK]
+                      REDISTRIBUTE arrA1[GEN_BLOCK]*/
+void distrmix16()
+{
+    #define AN1 12
+    double wb[7] = {1.0, 2., 2., 3.0, 1., 1., 0.5};
+    int* BS1, * BS2;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS2);
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrmix16";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[genblock(BS1)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+    #pragma dvm redistribute(A1[wgtblock(wb, 7)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] += 1;
+    }
+    #pragma dvm redistribute(A1[genblock(BS2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i + 1)
+                erri = Min(erri, i + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1);
+    free(BS2);
+    free(A1);
+    #undef AN1
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_MIX/distrmix2.cdv

@@ -0,0 +1,901 @@
+/*    DISTRMIX2
+Testing DISTRIBUTE and REDISTRIBUTE directive
+            GEN_BLOCK, WGT_BLOCK, MULT_BLOCK distributions
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+#ifndef _DVMH
+#define dvmh_get_num_procs(X) 1
+#endif
+
+static void distrmix21();
+static void distrmix22();
+static void distrmix23();
+static void distrmix24();
+static void distrmix25();
+static void distrmix26();
+static void distrmix27();
+static void distrmix28();
+static void distrmix29();
+static void distrmix210();
+static void distrmix211();
+static void distrmix212();
+static void distrmix213();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, errib, i, j, k, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRMIX2 ===================\n");
+
+    /* 21  DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]*/
+    distrmix21();
+    /* 22  DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK]*/
+    distrmix22();
+    /* 23  DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [WGT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][WGT_BLOCK]*/
+    distrmix23();
+    /* 24  DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]*/
+    distrmix24();
+    /* 25  DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK]*/
+    distrmix25();
+    /* 26  DISTRIBUTE arrA2[WGT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][WGT_BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK]*/
+    distrmix26();
+    /* 27  DISTRIBUTE arrA2[BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][WGT_BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][BLOCK]*/
+    distrmix27();
+    /* 28  DISTRIBUTE arrA2[BLOCK][GEN_BLOCK]
+              REDISTRIBUTE [WGT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [BLOCK][WGT_BLOCK]*/
+    distrmix28();
+    /* 29  DISTRIBUTE arrA2[WGT_BLOCK][BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK]
+              REDISTRIBUTE [BLOCK][MULT_BLOCK]*/
+    distrmix29();
+    /* 210  DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]
+               REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+               REDISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]*/
+    distrmix210();
+    /* 211  DISTRIBUTE arrA2[WGT_BLOCK][BLOCK]
+               REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+              REDISTRIBUTE arrA2[BLOCK][WGT_BLOCK]*/
+    distrmix211();
+    /* 212  DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+               REDISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]
+               REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]*/
+    distrmix212();
+    /* 213  DISTRIBUTE arrA2[BLOCK][GEN_BLOCK]
+               REDISTRIBUTE arrA2[WGT_BLOCK][MULT_BLOCK]
+               REDISTRIBUTE arrA2[GEN_BLOCK][BLOCK]*/
+    distrmix213();
+
+    printf("=== END OF DISTRMIX2 =====================\n");
+    return 0;
+}
+
+static int myRand() {
+    const unsigned a = 1103515245U;
+    const unsigned c = 12345U;
+    const unsigned m = ((unsigned)RAND_MAX) + 1U;
+    static unsigned prev = 5;
+    prev = (a * prev + c) % m;
+    return prev;
+}
+
+static void genBlocksAxis(const int procCount, const int weight, const int withoutZero, int **blocks) {
+    *blocks = (int *)malloc(procCount * sizeof(int));
+    int restWeight = weight, i, zeroind = -1;
+    if (!withoutZero && procCount > 1)
+        zeroind = myRand() % (procCount - 1);
+    for (i = 0; i < (procCount - 1); i++) {
+        if (i == zeroind)
+            (*blocks)[i] = 0;
+        else
+            (*blocks)[i] = 1 * withoutZero + myRand() % (restWeight - (procCount - (i + 1)));
+        restWeight -= (*blocks)[i];
+    }
+    (*blocks)[i] = restWeight;
+}
+
+/* ---------------------------------------------DISTR21*/
+/*DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+             REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK]
+             REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]*/
+void distrmix21()
+{
+    #define AN1 10
+    #define AN2 56
+    int m11 = 2, m12 = 7;
+    int m21 = 5, m22 = 8;
+    double wb1[8] = {1.0, 2., 1., 3.2, 1.0, 1.5, 2.3, 2.};
+    double wb2[7] = {1.3, 1.5, 2.2, 1.6, 2.6, 0.5, 1.7};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix21";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[multblock(m11)][multblock(m12)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[wgtblock(wb1, 8)][wgtblock(wb2, 7)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[multblock(m21)][multblock(m22)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR22*/
+/*DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK]*/
+void distrmix22()
+{
+    #define AN1 16
+    #define AN2 32
+    int m1 = 2, m2 = 4;
+    double wb1[7] = {2.4, 1.2, 3.0, 0.2, 1.5, 2.8, 2.1};
+    double wb2[6] = {2.0, 1.2, 2.6, 1.6, 3.5, 0.7};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix22";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb1, 7)][wgtblock(wb2, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+    #pragma dvm redistribute(A2[multblock(m1)][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                    A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[wgtblock(wb2, 6)][wgtblock(wb1, 7)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR23*/
+/*DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [WGT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][WGT_BLOCK]*/
+void distrmix23()
+{
+    #define AN1 18
+    #define AN2 12
+    int m11 = 2, m12 = 2;
+    int m21 = 3, m22 = 3;
+    double wb1[10] = {2., 1.2, 2., 2.5, 0.2, 1.5, 1., 2.8, 2.1, 3.};
+    double wb2[8] = {3.0, 3.5, 2.0, 1.2, 2.6, 1.6, 3.5, 0.7};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix23";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[multblock(m11)][multblock(m12)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+    #pragma dvm redistribute(A2[wgtblock(wb1, 10)][multblock(m22)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[multblock(m21)][wgtblock(wb2, 8)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR24*/
+/*DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]*/
+void distrmix24()
+{
+    #define AN1 30
+    #define AN2 30
+    int m1 = 3, m2 = 5;
+    int *BS1i, *BS1j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix24";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[multblock(m1)][multblock(m2)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+    #pragma dvm redistribute(A2[genblock(BS1i)][genblock(BS1j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[multblock(m2)][multblock(m1)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR25*/
+/*DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK]*/
+void distrmix25()
+{
+    #define AN1 16
+    #define AN2 12
+    int m1 = 2, m2 = 3;
+    int *BS1i, *BS1j, *BS2i, *BS2j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS2i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS2j);
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix25";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[genblock(BS1i)][genblock(BS1j)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+    #pragma dvm redistribute(A2[multblock(m1)][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[genblock(BS2i)][genblock(BS2j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(BS2i);
+    free(BS2j);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR26*/
+/*DISTRIBUTE arrA2[WGT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][WGT_BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK]*/
+void distrmix26()
+{
+    #define AN1 52
+    #define AN2 50
+    int m1 = 13, m2 = 5;
+    int *BS1i, *BS1j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    double wb1[6] = {2.4, 2.2, 0.2, 3.5, 1.2, 1.};
+    double wb2[8] = {1.0, 2.5, 3.0, 2.8, 1.6, 1., 0.5, 1.7};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix26";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb1, 6)][multblock(m2)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+    #pragma dvm redistribute(A2[multblock(m1)][wgtblock(wb2, 8)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[genblock(BS1i)][genblock(BS1j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR27*/
+/*DISTRIBUTE arrA2[BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][WGT_BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][BLOCK]*/
+void distrmix27()
+{
+    #define AN1 8
+    #define AN2 64
+    int m1 = 2, m2 = 8;
+    int *BS;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS);
+    double wb[7] = {2., 3.2, 2., 3.5, 1.2, 1., 4.};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix27";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[block][multblock(m2)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[multblock(m1)][wgtblock(wb, 7)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[genblock(BS)][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR28*/
+/*DISTRIBUTE arrA2[BLOCK][GEN_BLOCK]
+              REDISTRIBUTE [WGT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [BLOCK][WGT_BLOCK]*/
+void distrmix28()
+{
+    #define AN1 42
+    #define AN2 16
+    int m1 = 3, m2 = 2;
+    int *BS;
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS);
+    double wb1[6] = {2., 3., 1.2, 1.5, 1., 1.5};
+    double wb2[7] = {2.2, 1.5, 3.0, 2.8, 2.6, 1.4, 0.5};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix28";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[block][genblock(BS)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[wgtblock(wb1, 6)][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[block][wgtblock(wb2, 7)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR29*/
+/*DISTRIBUTE arrA2[WGT_BLOCK][BLOCK]
+              REDISTRIBUTE [GEN_BLOCK][GEN_BLOCK]
+              REDISTRIBUTE [BLOCK][MULT_BLOCK]*/
+void distrmix29()
+{
+    #define AN1 21
+    #define AN2 48
+    int m1 = 3, m2 = 2;
+    int *BS1i, *BS1j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    double wb[9] = {2.2, 1.5, 3.0, 2.8, 2.6, 1.4, 0.5, 1., 2.};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix29";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb, 9)][block])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[genblock(BS1i)][genblock(BS1j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[block][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR210*/
+/*DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]
+               REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+               REDISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]*/
+void distrmix210()
+{
+    #define AN1 9
+    #define AN2 11
+
+    int *BS1i, *BS1j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    double wb1[6] = {1.0, 1.2, 2.5, 1.4, 2.5, 1.3};
+    double wb2[4] = {1.0, 2., 1.5, 1.7};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix210";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb1, 6)][wgtblock(wb2, 4)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[genblock(BS1i)][genblock(BS1j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[wgtblock(wb2, 4)][wgtblock(wb1, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR211*/
+/*DISTRIBUTE arrA2[WGT_BLOCK][BLOCK]
+               REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+               REDISTRIBUTE arrA2[BLOCK][WGT_BLOCK]*/
+void distrmix211()
+{
+    #define AN1 16
+    #define AN2 16
+
+    int *BS1i, *BS1j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    double wb[7] = {1.0, 1.2, 2.5, 1.4, 2.5, 1.3, 2};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix211";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb, 7)][block])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[genblock(BS1i)][genblock(BS1j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[block][wgtblock(wb, 7)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR212*/
+/*DISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]
+               REDISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]
+               REDISTRIBUTE arrA2[GEN_BLOCK][GEN_BLOCK]*/
+void distrmix212()
+{
+    #define AN1 6
+    #define AN2 28
+
+    int *BS1i, *BS1j, *BS2i, *BS2j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS2i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS2j);
+    double wb1[8] = {1.0, 1.2, 2.5, 1.4, 2.5, 1.3, 1., 2.};
+    double wb2[5] = {2., 1.3, 2., 1.0, 1.7};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix212";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[genblock(BS1i)][genblock(BS1j)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[wgtblock(wb1, 6)][wgtblock(wb2, 4)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[genblock(BS2i)][genblock(BS2j)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(BS2i);
+    free(BS2j);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR213*/
+/*DISTRIBUTE arrA2[BLOCK][GEN_BLOCK]
+               REDISTRIBUTE arrA2[WGT_BLOCK][MULT_BLOCK]
+               REDISTRIBUTE arrA2[GEN_BLOCK][BLOCK]*/
+void distrmix213()
+{
+    #define AN1 27
+    #define AN2 14
+    int m1 = 3, m2 = 2;
+    int *BS1i, *BS1j;
+    genBlocksAxis(dvmh_get_num_procs(1), AN1, 1, &BS1i);
+    genBlocksAxis(dvmh_get_num_procs(2), AN2, 1, &BS1j);
+    double wb[4] = {1.2, 1.6, 2.0, 1.8};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrmix213";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[block][genblock(BS1j)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[wgtblock(wb, 4)][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] += 1;
+    }
+    #pragma dvm redistribute(A2[genblock(BS1i)][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j + 1)
+                    erri = Min(erri, i * NL + j + 1);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(BS1i);
+    free(BS1j);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_MULT/distrmult1.cdv

@@ -0,0 +1,474 @@
+/*    DISTRMULT1
+    TESTING distribute and redistribute directive
+            MULT_BLOCK distribution*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distrm11();
+static void distrm12();
+static void distrm13();
+static void distrm14();
+static void distrm15();
+static void distrm16();
+static void distrm17();
+static void distrm21();
+static void distrm22();
+static void distrm23();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, k, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRMULT1 ===================\n");
+
+    /* 11  DISTRIBUTE arrA1[BLOCK]       REDISTRIBUTE arrA1[MULT_BLOCK] */
+    distrm11();
+    /* 12  DISTRIBUTE arrA1[MULT_BLOCK]  REDISTRIBUTE arrA1[BLOCK] */
+    distrm12();
+    /* 13  DISTRIBUTE arrA1[BLOCK]       REDISTRIBUTE arrA1[MULT_BLOCK] small array*/
+    distrm13();
+    /* 14  DISTRIBUTE arrA1[MULT_BLOCK]  REDISTRIBUTE arrA1[BLOCK] small array*/
+    distrm14();
+    /* 15  DISTRIBUTE arrA1[MULT_BLOCK]  REDISTRIBUTE arrA1[MULT_BLOCK] other m*/
+    distrm15();
+    /* 16  DISTRIBUTE arrA1[MULT_BLOCK]  REDISTRIBUTE arrA1[*]*/
+    distrm16();
+    /* 17  DISTRIBUTE arrA1[*]           REDISTRIBUTE arrA1[MULT_BLOCK]*/
+    distrm17();
+    /* 21  DISTRIBUTE arrA2[MULT_BLOCK][*]   REDISTRIBUTE arrA2[*][MULT_BLOCK]*/
+    distrm21();
+    /* 22  DISTRIBUTE arrA2[*][MULT_BLOCK]   REDISTRIBUTE arrA2[*][*]*/
+    distrm22();
+    /* 23  DISTRIBUTE arrA2[*][*]            REDISTRIBUTE arrA2[*][MULT_BLOCK]*/
+    distrm23();
+
+    printf("=== END OF DISTRMULT1 =====================\n");
+    return 0;
+}
+
+/* ---------------------------------------------DISTR11*/
+/* DISTR arrA1[BLOCK]    REDISTR arrA1[MULT_BLOCK]*/
+void distrm11()
+{
+    #define AN1 25
+    int m = 5;
+    #pragma dvm array distribute[block]
+    int (*A1);
+    char tname[] = "distrm11";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[multblock(m)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR12*/
+/* DISTRIBUTE arrA1[MULT_BLOCK]    REDISTRIBUTE arrA1[BLOCK] */
+void distrm12()
+{
+    #define AN1 48
+    int m = 6;
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrm12";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[multblock(m)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR13*/
+/* DISTR arrA1[BLOCK]    REDISTR arrA1[MULT_BLOCK] small array */
+void distrm13()
+{
+    #define AN1 4
+    int m = 4;
+    #pragma dvm array distribute[block]
+    int (*A1);
+    char tname[] = "distrm13";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[multblock(m)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR14*/
+/*  DISTRIBUTE arrA1[MULT_BLOCK]   REDISTRIBUTE arrA1[BLOCK]  small array*/
+void distrm14()
+{
+    #define AN1 3
+    int m = 3;
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrm14";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[multblock(m)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR15*/
+/*  DISTR arrA1[MULT_BLOCK]    REDISTR arrA1[MULT_BLOCK] other m */
+void distrm15()
+{
+    #define AN1 24
+    int m1 = 4, m2 = 3;
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrm15";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[multblock(m1)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR16*/
+/*  DISTR arrA1[MULT_BLOCK]    REDISTR arrA1[*]*/
+void distrm16()
+{
+    #define AN1 50
+    int m = 2;
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrm16";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[multblock(m)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR17*/
+/*  DISTRIBUTE arrA1[*]    REDISTRIBUTE arrA1[MULT_BLOCK]*/
+void distrm17()
+{
+    #define AN1 120
+    int m = 10;
+    #pragma dvm array distribute[*]
+    int (*A1);
+    char tname[] = "distrm17";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[multblock(m)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR21*/
+/*  DISTRIBUTE arrA2[MULT_BLOCK][*]    REDISTRIBUTE arrA2[*][MULT_BLOCK] */
+void distrm21()
+{
+    #define AN1 36
+    #define AN2 25
+    int m1 = 6,m2 = 5;
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrm21";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[multblock(m1)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[*][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR22*/
+/*  DISTRIBUTE arrA2[*][MULT_BLOCK]    REDISTRIBUTE arrA2[*][*] */
+void distrm22()
+{
+    #define AN1 8
+    #define AN2 121
+    int m2 = 11;
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrm22";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[*][multblock(m2)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR23*/
+/*  DISTRIBUTE arrA2[*][*]    REDISTRIBUTE arrA2[*][MULT_BLOCK] */
+void distrm23()
+{
+    #define AN1 8
+    #define AN2 63
+    int m2 = 9;
+    #pragma dvm array distribute[*][*]
+    int (*A2)[AN2];
+    char tname[] = "distrm23";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[*][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_MULT/distrmult2.cdv

@@ -0,0 +1,857 @@
+/*    DISTRMULT2
+    TESTING distribute and redistribute directive
+            MULT_BLOCK distribution*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distrm24();
+static void distrm25();
+static void distrm26();
+static void distrm27();
+static void distrm28();
+static void distrm29();
+static void distrm210();
+static void distrm32();
+static void distrm33();
+static void distrm34();
+static void distrm35();
+static void distrm36();
+static void distrm37();
+static void distrm38();
+static void distrm41();
+static void distrm42();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, k, ia, ib, n;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRMULT2 ===================\n");
+
+    /* 24  DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]  REDISTRIBUTE arrA2[*][*]*/
+    distrm24();
+    /* 25  DISTRIBUTE arrA2[*][*]  REDISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]*/
+    distrm25();
+    /* 26  DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+                             REDISTRIBUTE arrA2[BLOCK][BLOCK]*/
+    distrm26();
+    /* 27  DISTRIBUTE arrA2[BLOCK][BLOCK]
+                             REDISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]*/
+    distrm27();
+    /* 28  DISTRIBUTE arrA2[MULT_BLOCK][BLOCK]
+                         REDISTRIBUTE arrA2[BLOCK][MULT_BLOCK]*/
+    distrm28();
+    /* 29  DISTRIBUTE arrA2[BLOCK][MULT_BLOCK]
+                         REDISTRIBUTE arrA2[MULT_BLOCK][BLOCK]*/
+    distrm29();
+    /* 210  DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]  other m1,m2*/
+    distrm210();
+    /* 32  DISTRIBUTE  arrA3[MULT_BLOCK][MULT_BLOCK] [*]
+                         REDISTRIBUTE arrA3[*][MULT_BLOCK][MULT_BLOCK]*/
+    distrm32();
+    /* 33  DISTRIBUTE  arrA3[MULT_BLOCK][MULT_BLOCK][*]
+                          REDISTRIBUTE arrA3[MULT_BLOCK][*][BLOCK]*/
+    distrm33();
+    /* 34  DISTRIBUTE  arrA3[MULT_BLOCK][*][MULT_BLOCK]
+                         REDISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][*]*/
+    distrm34();
+    /* 35  DISTRIBUTE  arrA3[MULT_BLOCK][MULT_BLOCK][*]
+                         REDISTRIBUTE arrA3[*][*]MULT_BLOCK]*/
+    distrm35();
+    /* 36  DISTRIBUTE  arrA3[MULT_BLOCK][*][BLOCK]
+                         REDISTRIBUTE arrA3[BLOCK][*][MULT_BLOCK]*/
+    distrm36();
+    /* 37  DISTRIBUTE  arrA3[MULT_BLOCK][BLOCK][*]
+                         REDISTRIBUTE arrA3[BLOCK][*][MULT_BLOCK]*/
+    distrm37();
+    /* 38  DISTRIBUTE  arrA3[BLOCK][*][MULT_BLOCK]
+                         REDISTRIBUTE arrA3[*][MULT_BLOCK][BLOCK]*/
+    distrm38();
+    /* 41  DISTRIBUTE arrA4[*][*][MULT_BLOCK][MULT_BLOCK]
+                         REDISTRIBUTE arrA4[*][*][*][*]*/
+    distrm41();
+    /* 42  DISTRIBUTE arrA4[MULT_BLOCK][*][MULT_BLOCK][*]
+                        REDISTRIBUTE arrA4[*][MULT_BLOCK][MULT_BLOCK][*]*/
+    distrm42();
+
+    printf("=== END OF DISTRMULT2 =====================\n");
+    return 0;
+}
+
+/* ---------------------------------------------DISTR24*/
+/* DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]  REDISTRIBUTE arrA2[*][*] */
+void distrm24()
+{
+    #define AN1 15
+    #define AN2 12
+    int m1 = 5,m2 = 3;
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrm24";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[multblock(m1)][multblock(m2)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR25*/
+/* DISTRIBUTE arrA2[*][*]  REDISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]*/
+void distrm25()
+{
+    #define AN1 18
+    #define AN2 8
+    int m1 = 3,m2 = 2;
+    #pragma dvm array distribute[*][*]
+    int (*A2)[AN2];
+    char tname[] = "distrm25";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[multblock(m1)][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+
+/* ---------------------------------------------DISTR26*/
+/* DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+                REDISTRIBUTE arrA2[BLOCK][BLOCK]*/
+void distrm26()
+{
+    #define AN1 49
+    #define AN2 12
+    int m1 = 7,m2 = 4;
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrm26";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[multblock(m1)][multblock(m2)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[block][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR27*/
+/*  DISTRIBUTE arrA2[BLOCK][BLOCK]  REDISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]*/
+void distrm27()
+{
+    #define AN1 8
+    #define AN2 64
+    int m1 = 1,m2 = 8;
+    #pragma dvm array distribute[block][block]
+    int (*A2)[AN2];
+    char tname[] = "distrm27";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[multblock(m1)][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR28*/
+/* DISTRIBUTE arrA2[MULT_BLOCK][BLOCK]  REDISTRIBUTE arrA2[BLOCK][MULT_BLOCK]*/
+void distrm28()
+{
+    #define AN1 20
+    #define AN2 20
+    int m1 = 5, m2 = 4;
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrm28";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[multblock(m1)][block])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[block][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR29*/
+/* DISTRIBUTE arrA2[BLOCK][MULT_BLOCK]
+                REDISTRIBUTE arrA2[MULT_BLOCK][BLOCK]*/
+void distrm29()
+{
+    #define AN1 30
+    #define AN2 60
+    int m1 = 10,m2 = 10;
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrm29";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[block][multblock(m2)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[multblock(m1)][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR210*/
+/* DISTRIBUTE arrA2[MULT_BLOCK][MULT_BLOCK]
+                 REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK]  other m1, m2*/
+void distrm210()
+{
+    #define AN1 24
+    #define AN2 24
+    int m1 = 3,m2 = 2;
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrm210";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[multblock(m1)][multblock(m2)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[multblock(m2)][multblock(m1)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR32*/
+/* DISTRIBUTE  arrA3[MULT_BLOCK][MULT_BLOCK] [*]
+                 REDISTRIBUTE arrA3[*][MULT_BLOCK][MULT_BLOCK]*/
+void distrm32()
+{
+    #define AN1 16
+    #define AN2 12
+    #define AN3 8
+    int m1 = 2, m2 = 3, m3 = 4;
+    #pragma dvm array
+
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm32";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][multblock(m2)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][multblock(m2)][multblock(m3)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR33*/
+/* DISTRIBUTE  arrA3[MULT_BLOCK][MULT_BLOCK][*]
+                 REDISTRIBUTE arrA3[MULT_BLOCK][*][MULTBLOCK]*/
+void distrm33()
+{
+    #define AN1 16
+    #define AN2 16
+    #define AN3 8
+    int m1 = 4, m2 = 2, m3 = 2;
+    #pragma dvm array
+
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm33";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][multblock(m2)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[multblock(m1)][*][multblock(m3)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR34*/
+/* DISTRIBUTE  arrA3[MULT_BLOCK][*][MULT_BLOCK]
+                 REDISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][*]*/
+void distrm34()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    int m1 = 2, m2 = 1, m3 = 4;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm34";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][*][multblock(m3)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[multblock(m1)][multblock(m2)][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR35*/
+/* DISTRIBUTE  arrA3[MULT_BLOCK][MULT_BLOCK][*]
+                         REDISTRIBUTE arrA3[*][*][MULT_BLOCK]*/
+void distrm35()
+{
+    #define AN1 18
+    #define AN2 28
+    #define AN3 38
+    int m1 = 3, m2 = 7, m3 = 19;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm35";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][multblock(m2)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][*][multblock(m3)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR36*/
+/* DISTRIBUTE  arrA3[MULT_BLOCK][*][BLOCK]
+                         REDISTRIBUTE arrA3[BLOCK][*][MULT_BLOCK]*/
+void distrm36()
+{
+    #define AN1 121
+    #define AN2 12
+    #define AN3 35
+    int m1 = 11, m2 = 2, m3 = 7;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm36";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][*][block])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[block][*][multblock(m3)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR37*/
+/*DISTRIBUTE  arrA3[MULT_BLOCK][BLOCK][*]
+                         REDISTRIBUTE arrA3[BLOCK][*][MULT_BLOCK]*/
+void distrm37()
+{
+    #define AN1 8
+    #define AN2 28
+    #define AN3 8
+    int m1 = 2, m2 = 4, m3 = 2;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm37";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][block][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[block][*][multblock(m3)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR38*/
+/*DISTRIBUTE  arrA3[BLOCK][*][MULT_BLOCK] REDISTRIBUTE arrA3[*][MULT_BLOCK][MULT_BLOCK]*/
+void distrm38()
+{
+    #define AN1 8
+    #define AN2 28
+    #define AN3 8
+    int m1 = 2, m2 = 4, m3 = 2;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm38";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[block][*][multblock(m3)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][multblock(m2)][multblock(m3)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR41*/
+/*DISTRIBUTE arrA4[*][*][MULT_BLOCK][MULT_BLOCK] REDISTRIBUTE arrA4[*][*][*][*]*/
+void distrm41()
+{
+    #define AN1 16
+    #define AN2 16
+    #define AN3 16
+    #define AN4 16
+    int m1 = 2, m2 = 4, m3 = 2, m4 = 4;
+    #pragma dvm array
+    int (*A4)[AN2][AN3][AN4];
+    char tname[] = "distrm41";
+
+    erri = ER;
+
+    A4 = malloc(AN1 * AN2 * AN3 * AN4 * sizeof(int));
+    #pragma dvm redistribute(A4[*][*][multblock(m3)][multblock(m4)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        A4[i][j][k][n] = i*NL/10+j*NL/100+k*NL/1000+n;
+    }
+
+    #pragma dvm redistribute(A4[*][*][*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        if (A4[i][j][k][n] != i*NL/10+j*NL/100+k*NL/1000+n)
+                            erri = Min(erri, i*NL/10+j*NL/100+k*NL/1000+n);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A4);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+
+/* ---------------------------------------------DISTR42*/
+/*DISTRIBUTE arrA4[MULT_BLOCK][*][MULT_BLOCK][*]
+                REDISTRIBUTE arrA4[*][MULT_BLOCK][MULT_BLOCK][*]*/
+void distrm42()
+{
+    #define AN1 28
+    #define AN2 25
+    #define AN3 27
+    #define AN4 21
+    int m1 = 7, m2 = 5, m3 = 9, m4 = 3;
+    #pragma dvm array
+    int (*A4)[AN2][AN3][AN4];
+    char tname[] = "distrm42";
+
+    erri = ER;
+
+    A4 = malloc(AN1 * AN2 * AN3 * AN4 * sizeof(int));
+    #pragma dvm redistribute(A4[multblock(m1)][*][multblock(m3)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        A4[i][j][k][n] = i*NL/10+j*NL/100+k*NL/1000+n;
+    }
+
+    #pragma dvm redistribute(A4[*][multblock(m2)][multblock(m3)][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        if (A4[i][j][k][n] != i*NL/10+j*NL/100+k*NL/1000+n)
+                            erri = Min(erri, i*NL/10+j*NL/100+k*NL/1000+n);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A4);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_MULT/distrmult3.cdv

@@ -0,0 +1,569 @@
+/*    DISTRMULT3
+    TESTING distribute and redistribute directive
+            MULT_BLOCK distribution*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distrm311();
+static void distrm312();
+static void distrm313();
+static void distrm314();
+static void distrm315();
+static void distrm316();
+static void distrm317();
+static void distrm318();
+static void distrm319();
+static void distrm43();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, k, ia, ib, n;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRMULT3 ===================\n");
+
+    /* 311 DISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]
+                REDISTRIBUTE [BLOCK][BLOCK][BLOCK]*/
+    distrm311();
+    /* 312 DISTRIBUTE arrA3DISTRIBUTE [BLOCK][BLOCK][BLOCK]
+               REDISTRIBUTE  [MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]*/
+    distrm312();
+    /* 313 DISTRIBUTE arrA2[_BLOCK][BLOCK][WGT_BLOCK]
+                REDISTRIBUTE arrA3[BLOCK][MULT_BLOCK][BLOCK]*/
+    distrm313();
+    /* 314 DISTRIBUTE arrA3[BLOCK][MULT_BLOCK][BLOCK]
+                REDISTRIBUTE arrA3[MULT_BLOCK][BLOCK][MULT_BLOCK]*/
+    distrm314();
+    /* 315  DISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]
+              REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK][MULT_BLOCK] other m1,m2,m3*/
+    distrm315();
+    /* 316 DISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]
+                REDISTRIBUTE arrA2[*][*][*]*/
+    distrm316();
+    /* 317  DISTRIBUTE arrA3[*][*][*]
+                REDISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]*/
+    distrm317();
+    /* 318 DISTRIBUTE arrA3[MULT_BLOCK][*][MULT_BLOCK]
+                REDISTRIBUTE arrA3[*][MULT_BLOCK][*]*/
+    distrm318();
+    /* 319 DISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][*]
+                REDISTRIBUTE arrA3[*][MULT_BLOCK][MULT_BLOCK]*/
+    distrm319();
+    /* 43 DISTRIBUTE arrA4[MULT_BLOCK][*][MULT_BLOCK][*]
+                REDISTRIBUTE arrA4[[*][MULT_BLOCK][*][MULT_BLOCK]*/
+    distrm43();
+
+    printf("=== END OF DISTRMULT3 =====================\n");
+    return 0;
+}
+
+/* ---------------------------------------------DISTR311*/
+/*DISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]
+                REDISTRIBUTE [BLOCK][BLOCK][BLOCK]*/
+void distrm311()
+{
+    #define AN1 14
+    #define AN2 12
+    #define AN3 10
+    int m1 = 7, m2 = 3, m3 = 5;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm311";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][multblock(m2)][multblock(m3)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[block][block][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR312*/
+/*DISTRIBUTE arrA3[BLOCK][BLOCK][BLOCK]
+                REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]*/
+void distrm312()
+{
+    #define AN1 15
+    #define AN2 15
+    #define AN3 25
+    int m1 = 5, m2 = 5, m3 = 5;
+    #pragma dvm array distribute[block][block][block]
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm312";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[multblock(m1)][multblock(m2)][multblock(m3)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR313*/
+/*DISTRIBUTE arrA2[MULT_BLOCK][BLOCK][MULT_BLOCK]
+                REDISTRIBUTE arrA3[BLOCK][MULT_BLOCK][BLOCK]*/
+void distrm313()
+{
+    #define AN1 24
+    #define AN2 24
+    #define AN3 24
+    int m1 = 2, m2 = 3, m3 = 4;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm313";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][block][multblock(m3)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[block][multblock(m2)][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR314*/
+/*DISTRIBUTE arrA3[BLOCK][MULT_BLOCK][BLOCK]
+                REDISTRIBUTE arrA3[MULT_BLOCK][BLOCK][MULT_BLOCK]*/
+void distrm314()
+{
+    #define AN1 20
+    #define AN2 30
+    #define AN3 30
+    int m1 = 5, m2 = 3, m3 = 3;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm314";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[block][multblock(m2)][block])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[multblock(m1)][block][multblock(m3)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR315*/
+/*DISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]
+            REDISTRIBUTE [MULT_BLOCK][MULT_BLOCK][MULT_BLOCK] other m1,m2,m3*/
+void distrm315()
+{
+    #define AN1 16
+    #define AN2 16
+    #define AN3 16
+    int m1 = 2, m2 = 4, m3 = 8;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm315";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][multblock(m2)][multblock(m3)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[multblock(m3)][multblock(m1)][multblock(m2)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR316*/
+/*DISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]
+                REDISTRIBUTE arrA2[*][*][*]*/
+void distrm316()
+{
+    #define AN1 12
+    #define AN2 12
+    #define AN3 48
+    int m1 = 3, m2 = 2, m3 = 6;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm316";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][multblock(m2)][multblock(m3)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR317*/
+/*DISTRIBUTE arrA3[*][*][*]
+                REDISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][MULT_BLOCK]*/
+void distrm317()
+{
+    #define AN1 10
+    #define AN2 35
+    #define AN3 10
+    int m1 = 2, m2 = 5, m3 = 2;
+    #pragma dvm array distribute[*][*][*]
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm317";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[multblock(m1)][multblock(m2)][multblock(m3)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR318*/
+/*DISTRIBUTE arrA3[MULT_BLOCK][*][MULT_BLOCK]
+                REDISTRIBUTE arrA3[*][MULT_BLOCK][*]*/
+void distrm318()
+{
+    #define AN1 11
+    #define AN2 14
+    #define AN3 24
+    int m1 = 1, m2 = 2, m3 = 6;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm318";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m1)][*][multblock(m3)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][multblock(m2)][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR319*/
+/*DISTRIBUTE arrA3[MULT_BLOCK][MULT_BLOCK][*]
+               REDISTRIBUTE arrA3[*][MULT_BLOCK][MULT_BLOCK]*/
+void distrm319()
+{
+    #define AN1 30
+    #define AN2 12
+    #define AN3 30
+    int m11 = 2, m12 = 2, m13 = 2;
+    int m21 = 5, m22 = 4, m23 = 10;
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrm319";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[multblock(m11)][multblock(m12)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][multblock(m22)][multblock(m23)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR43*/
+/*DISTRIBUTE arrA4[MULT_BLOCK][*][MULT_BLOCK][*]
+                REDISTRIBUTE arrA4[*][MULT_BLOCK][*][MULT_BLOCK]*/
+void distrm43()
+{
+    #define AN1 16
+    #define AN2 16
+    #define AN3 16
+    #define AN4 16
+    int m1 = 2, m2 = 4, m3 = 2, m4 = 4;
+    #pragma dvm array
+    int (*A4)[AN2][AN3][AN4];
+    char tname[] = "distrm43";
+
+    erri = ER;
+
+    A4 = malloc(AN1 * AN2 * AN3 * AN4 * sizeof(int));
+    #pragma dvm redistribute(A4[multblock(m1)][*][multblock(m3)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        A4[i][j][k][n] = i*NL/10+j*NL/100+k*NL/1000+n;
+    }
+
+    #pragma dvm redistribute(A4[*][multblock(m2)][*][multblock(m4)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        if (A4[i][j][k][n] != i*NL/10+j*NL/100+k*NL/1000+n)
+                            erri = Min(erri, i*NL/10+j*NL/100+k*NL/1000+n);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A4);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_WGT/distrwgt1.cdv

@@ -0,0 +1,483 @@
+/*    DISTRWGT1
+    Testing DISTRIBUTE and REDISTRIBUTE directives
+            WGT_BLOCK distribution*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distrwgt11();
+static void distrwgt12();
+static void distrwgt13();
+static void distrwgt14();
+static void distrwgt15();
+static void distrwgt16();
+static void distrwgt17();
+static void distrwgt21();
+static void distrwgt22();
+static void distrwgt23();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, k, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRWGT1 ===================\n");
+    /* 11  DISTRIBUTE arrA1[BLOCK]       REDISTRIBUTE arrA1[WGT_BLOCK]*/
+    distrwgt11();
+
+    /* DISTRIBUTE arrA1[WGT_BLOCK]   REDISTRIBUTE arrA1[BLOCK] */
+    distrwgt12();
+
+    /* DISTRIBUTE arrA1[BLOCK]       REDISTRIBUTE arrA1[WGT_BLOCK] small array*/
+    distrwgt13();
+
+    /* DISTRIBUTE arrA1[WGT_BLOCK]   REDISTRIBUTE arrA1[BLOCK] small array*/
+    distrwgt14();
+
+    /* DISTRIBUTE arrA1[WGT_BLOCK]   REDISTRIBUTE arrA1[WGT_BLOCK] other weights*/
+    distrwgt15();
+
+    /* DISTRIBUTE arrA1[WGT_BLOCK]   REDISTRIBUTE arrA1[*]*/
+    distrwgt16();
+
+    /* DISTRIBUTE arrA1[*]           REDISTRIBUTE arrA1[WGT_BLOCK]*/
+    distrwgt17();
+
+    /* DISTRIBUTE arrA2[WGT_BLOCK][*]   REDISTRIBUTE arrA2[*][WGT_BLOCK]*/
+    distrwgt21();
+
+    /*DISTRIBUTE arrA2[*][WGT_BLOCK]   REDISTRIBUTE arrA2[*][*]*/
+    distrwgt22();
+
+    /* DISTRIBUTE arrA2[*][*]           REDISTRIBUTE arrA2[*][WGT_BLOCK]*/
+    distrwgt23();
+
+    printf("=== END OF DISTRWGT1 =====================\n");
+    return 0;
+}
+
+/* ---------------------------------------------DISTR11*/
+/* 11  DISTRIBUTE arrA1[BLOCK]       REDISTRIBUTE arrA1[WGT_BLOCK]*/
+void distrwgt11()
+{
+    #define AN1 16
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array distribute[block]
+    int (*A1);
+    char tname[] = "distrwgt11";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[wgtblock(wb, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR12*/
+/* 11   12  DISTRIBUTE arrA1[WGT_BLOCK]   REDISTRIBUTE arrA1[BLOCK]*/
+void distrwgt12()
+{
+    #define AN1 8
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrwgt12";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[wgtblock(wb, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR13*/
+/* 13  DISTRIBUTE arrA1[BLOCK]       REDISTRIBUTE arrA1[WGT_BLOCK] small array*/
+void distrwgt13()
+{
+    #define AN1 5
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array distribute[block]
+    int (*A1);
+    char tname[] = "distrwgt13";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[wgtblock(wb, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR14*/
+/* 14  DISTRIBUTE arrA1[WGT_BLOCK]   REDISTRIBUTE arrA1[BLOCK] small array*/
+void distrwgt14()
+{
+    #define AN1 5
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrwgt14";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[wgtblock(wb, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR15*/
+/* 15 DISTRIBUTE arrA1[WGT_BLOCK]   REDISTRIBUTE arrA1[WGT_BLOCK] other weights*/
+void distrwgt15()
+{
+    #define AN1 16
+    double wb1[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    double wb2[6] = {2.0, 1., 2., 2.0, 2., 1.};
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrwgt15";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[wgtblock(wb1, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[wgtblock(wb2, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR16*/
+/* 16  DISTRIBUTE arrA1[WGT_BLOCK]   REDISTRIBUTE arrA1[*]*/
+void distrwgt16()
+{
+    #define AN1 8
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A1);
+    char tname[] = "distrwgt16";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+    #pragma dvm redistribute(A1[wgtblock(wb, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR17*/
+/* 17  DISTRIBUTE arrA1[*]   REDISTRIBUTE arrA1[WGT_BLOCK]*/
+void distrwgt17()
+{
+    #define AN1 28
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array distribute[*]
+    int (*A1);
+    char tname[] = "distrwgt17";
+
+    erri = ER;
+
+    A1 = malloc(AN1 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+                    A1[i] = i;
+    }
+
+    #pragma dvm redistribute(A1[wgtblock(wb, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on A1[i]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            if (A1[i] != i)
+                erri = Min(erri, i);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------DISTR17*/
+/* 21  DISTRIBUTE arrA2[WGT_BLOCK][*]   REDISTRIBUTE arrA2[*][WGT_BLOCK]*/
+void distrwgt21()
+{
+    #define AN1 8
+    #define AN2 8
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrwgt21";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb, 6)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[*][wgtblock(wb, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR22*/
+/* 22  DISTRIBUTE arrA2[*][WGT_BLOCK]   REDISTRIBUTE arrA2[*][*]*/
+void distrwgt22()
+{
+    #define AN1 8
+    #define AN2 8
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrwgt22";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[*][wgtblock(wb, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR23*/
+/* 23  DISTRIBUTE arrA2[*][*]           REDISTRIBUTE arrA2[*][WGT_BLOCK]*/
+void distrwgt23()
+{
+    #define AN1 8
+    #define AN2 8
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array distribute[*][*]
+    int (*A2)[AN2];
+    char tname[] = "distrwgt23";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[*][wgtblock(wb, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_WGT/distrwgt2.cdv

@@ -0,0 +1,859 @@
+/*    DISTRWGT2
+    Testing DISTRIBUTE and REDISTRIBUTE directives
+            WGT_BLOCK distribution*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distrwgt24();
+static void distrwgt25();
+static void distrwgt26();
+static void distrwgt27();
+static void distrwgt28();
+static void distrwgt29();
+static void distrwgt210();
+static void distrwgt32();
+static void distrwgt33();
+static void distrwgt34();
+static void distrwgt35();
+static void distrwgt36();
+static void distrwgt37();
+static void distrwgt38();
+static void distrwgt41();
+static void distrwgt42();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, k, n, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRWGT2 ===================\n");
+    /* 24  DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]  REDISTRIBUTE arrA2[*][*]*/
+    distrwgt24();
+    /* 25  DISTRIBUTE arrA2[*][*]  REDISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]*/
+    distrwgt25();
+    /* 26  DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]
+                             REDISTRIBUTE arrA2[BLOCK][BLOCK]*/
+    distrwgt26();
+    /* 27  DISTRIBUTE arrA2[BLOCK][BLOCK]
+                             REDISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]*/
+    distrwgt27();
+    /* 28  DISTRIBUTE arrA2[WGT_BLOCK][BLOCK]
+                         REDISTRIBUTE arrA2[BLOCK][WGT_BLOCK]*/
+    distrwgt28();
+    /* 29  DISTRIBUTE arrA2[BLOCK][WGT_BLOCK]
+                         REDISTRIBUTE arrA2[WGT_BLOCK][BLOCK]*/
+    distrwgt29();
+    /* 210  DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]    other weigths
+                      REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK]*/
+    distrwgt210();
+    /* 32  DISTRIBUTE  arrA3[WGT_BLOCK][WGT_BLOCK] [*]
+                      REDISTRIBUTE arrA3[*][WGT_BLOCK][WGT_BLOCK]*/
+    distrwgt32();
+    /* 33  DISTRIBUTE  arrA3[WGT_BLOCK][WGT_BLOCK][*]
+                     REDISTRIBUTE arrA3[WGT_BLOCK][*][BLOCK]*/
+    distrwgt33();
+    /* 34  DISTRIBUTE  arrA3[WGT_BLOCK][*][WGT_BLOCK]
+                      REDISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][*]*/
+    distrwgt34();
+    /* 35  DISTRIBUTE  arrA3[WGT_BLOCK][WGT_BLOCK][*]
+                      REDISTRIBUTE arrA3[*][*][WGT_BLOCK]*/
+    distrwgt35();
+    /* 36  DISTRIBUTE  arrA3[WGT_BLOCK][*][BLOCK]
+                      REDISTRIBUTE arrA3[BLOCK][*][WGT_BLOCK]*/
+    distrwgt36();
+   /* 37  DISTRIBUTE  arrA3[WGT_BLOCK][BLOCK][*]
+                      REDISTRIBUTE arrA3[BLOCK][*][WGT_BLOCK]*/
+    distrwgt37();
+    /* 38  DISTRIBUTE  arrA3[BLOCK][*][WGT_BLOCK]
+                      REDISTRIBUTE arrA3[*][WGT_BLOCK][BLOCK]*/
+    distrwgt38();
+    /* 41  DISTRIBUTE arrA4[*][*][WGT_BLOCK][WGT_BLOCK]
+                     REDISTRIBUTE arrA4[*][*][*][*]*/
+    distrwgt41();
+    /* 42  DISTRIBUTE arrA4[WGT_BLOCK][*][WGT_BLOCK][*]
+                     REDISTRIBUTE arrA4[*][WGT_BLOCK][WGT_BLOCK][*]*/
+    distrwgt42();
+
+    printf("=== END OF DISTRWGT2 =====================\n");
+    return 0;
+}
+
+/* ---------------------------------------------DISTR24*/
+/* 24   DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]  REDISTRIBUTE arrA2[*][*]*/
+void distrwgt24()
+{
+    #define AN1 8
+    #define AN2 8
+    double wb1[4] = {2., 2., 3.0, 1.};
+    double wb2[6] = {3.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrwgt24";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb1, 4)][wgtblock(wb2, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR25*/
+/* DISTRIBUTE arrA2[*][*]  REDISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]*/
+void distrwgt25()
+{
+    #define AN1 8
+    #define AN2 8
+    double wb1[5] = {1.0,2.,2.,3.0, 0.};
+    double wb2[7] = {1.0,1.,2.,1.0, 1.,1.,1.};
+    #pragma dvm array distribute[*][*]
+    int (*A2)[AN2];
+    char tname[] = "distrwgt25";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[wgtblock(wb1, 5)][wgtblock(wb2, 7)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR26*/
+/* DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]  REDISTRIBUTE arrA2[BLOCK][BLOCK]*/
+void distrwgt26()
+{
+    #define AN1 12
+    #define AN2 12
+    double wb[6] = {1.0, 4., 1., 1.0, 2., 1.};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrwgt26";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb, 6)][wgtblock(wb, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[block][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR27*/
+/* DISTRIBUTE arrA2[BLOCK][BLOCK]  REDISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]*/
+void distrwgt27()
+{
+    #define AN1 8
+    #define AN2 8
+    double wb[6] = {2.0, 1., 3., 2.0, 1., 1.};
+    #pragma dvm array distribute[block][block]
+    int (*A2)[AN2];
+    char tname[] = "distrwgt27";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[wgtblock(wb, 6)][wgtblock(wb, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR28*/
+/* DISTRIBUTE arrA2[WGT_BLOCK][BLOCK]  REDISTRIBUTE arrA2[BLOCK][WGT_BLOCK]*/
+void distrwgt28()
+{
+    #define AN1 12
+    #define AN2 12
+    double wb1[8] = {1.0, 2., 2., 3.0, 1., 1, 2, 4.};
+    double wb2[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrwgt28";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb1, 8)][block])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[block][wgtblock(wb2, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR29*/
+/* DISTRIBUTE arrA2[BLOCK][WGT_BLOCK]  REDISTRIBUTE arrA2[WGT_BLOCK][BLOCK]*/
+void distrwgt29()
+{
+    #define AN1 12
+    #define AN2 12
+    double wb1[6] = {1.0, 2., 2., 3.0, 3, 1};
+    double wb2[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrwgt29";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[block][wgtblock(wb1, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[wgtblock(wb2, 6)][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR210*/
+/* DISTRIBUTE arrA2[WGT_BLOCK][WGT_BLOCK]
+               REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK] with other weigths*/
+void distrwgt210()
+{
+    #define AN1 12
+    #define AN2 12
+    double wb1[4] = {1.0, 2., 1., 1.0};
+    double wb2[6] = {1.0, 1., 2., 1.0, 2., 1.};
+    #pragma dvm array
+    int (*A2)[AN2];
+    char tname[] = "distrwgt210";
+
+    erri = ER;
+
+    A2 = malloc(AN1 * AN2 * sizeof(int));
+    #pragma dvm redistribute(A2[wgtblock(wb1, 4)][wgtblock(wb2, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                A2[i][j] = i * NL + j;
+    }
+
+    #pragma dvm redistribute(A2[wgtblock(wb2, 6)][wgtblock(wb1, 4)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j] on A2[i][j]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                if (A2[i][j] != i * NL + j)
+                    erri = Min(erri, i * NL + j);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------DISTR32*/
+/* DISTRIBUTE  arrA3[WGT_BLOCK][WGT_BLOCK][*]
+                 REDISTRIBUTE arrA3[*][WGT_BLOCK][WGT_BLOCK]*/
+void distrwgt32()
+{
+    #define AN1 16
+    #define AN2 12
+    #define AN3 8
+    double wb1[7] = {1., 1., 2., 1.0, 2., 2., 3.0};
+    double wb2[8] = {1.0, 2., 2., 3.0, 2, 1, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt32";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb1, 7)][wgtblock(wb2, 6)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][wgtblock(wb2, 6)][wgtblock(wb1, 4)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR33*/
+/* DISTRIBUTE  arrA3[WGT_BLOCK][WGT_BLOCK][*]
+                 REDISTRIBUTE arrA3[WGT_BLOCK][*][WGT_BLOCK]*/
+void distrwgt33()
+{
+    #define AN1 16
+    #define AN2 16
+    #define AN3 8
+    double wb[10] = {1.0, 2., 2., 3.0, 2., 4, 2., 1., 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt33";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb, 6)][wgtblock(wb, 8)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[wgtblock(wb, 10)][*][wgtblock(wb, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR34*/
+/* DISTRIBUTE  arrA3[WGT_BLOCK][*][WGT_BLOCK]
+                 REDISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][*]*/
+void distrwgt34()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    double wb[8] = {1.0, 2., 2., 3.0, 1., 2, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt34";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb, 6)][*][wgtblock(wb, 8)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[wgtblock(wb, 8)][wgtblock(wb, 6)][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR35*/
+/* DISTRIBUTE  arrA3[WGT_BLOCK][BLOCK][*]
+                         REDISTRIBUTE arrA3[*][*][WGT_BLOCK]*/
+void distrwgt35()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    double wb1[6] = {1.0, 2., 2., 3.0, 1.5, 2.5};
+    double wb2[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt35";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb1, 6)][block][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][*][wgtblock(wb2, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR36*/
+/* DISTRIBUTE  arrA3[WGT_BLOCK][*][BLOCK]
+                         REDISTRIBUTE arrA3[BLOCK][*][WGT_BLOCK]*/
+void distrwgt36()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    double wb[6] = {.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt36";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb, 6)][*][block])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[block][*][wgtblock(wb, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR37*/
+/*DISTRIBUTE  arrA3[WGT_BLOCK][BLOCK][*]
+                         REDISTRIBUTE arrA3[BLOCK][*][WGT_BLOCK]*/
+void distrwgt37()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    double wb1[6] = {0.5, 1, 1.0, 2., 2., 3.0};
+    double wb2[8] = {1.0, 2., 2., 3.0, 0.5, 2, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt37";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb1, 6)][block][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[block][*][wgtblock(wb2, 8)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR38*/
+/*DISTRIBUTE  arrA3[BLOCK][*][WGT_BLOCK] REDISTRIBUTE arrA3[*][WGT_BLOCK][WGT_BLOCK]*/
+void distrwgt38()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    double wb1[6] = {1.0, 2., 2., 3.0, 4, 5};
+    double wb2[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt38";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[block][*][wgtblock(wb1, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][wgtblock(wb1, 6)][wgtblock(wb2, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR41*/
+/*DISTRIBUTE arrA4[*][*][WGT_BLOCK][WGT_BLOCK]
+                REDISTRIBUTE arrA4[*][*][*][*]*/
+void distrwgt41()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    #define AN4 8
+    double wb[8] = {1.0, 2., 2., 3.0, 1., 1., 2, 1};
+    #pragma dvm array
+    int (*A4)[AN2][AN3][AN4];
+    char tname[] = "distrwgt41";
+
+    erri = ER;
+
+    A4 = malloc(AN1 * AN2 * AN3 * AN4 * sizeof(int));
+    #pragma dvm redistribute(A4[*][*][wgtblock(wb, 6)][wgtblock(wb, 8)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        A4[i][j][k][n] = i*NL/10+j*NL/100+k*NL/1000+n;
+    }
+    #pragma dvm redistribute(A4[*][*][*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        if (A4[i][j][k][n] != i*NL/10+j*NL/100+k*NL/1000+n)
+                            erri = Min(erri, i*NL/10+j*NL/100+k*NL/1000+n);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A4);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+
+/* ---------------------------------------------DISTR42*/
+/*DISTRIBUTE arrA4[WGT_BLOCK][*][WGT_BLOCK][*] REDISTRIBUTE arrA4[*][WGT_BLOCK][WGT_BLOCK][*]*/
+void distrwgt42()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    #define AN4 8
+    double wb[6] = {1.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A4)[AN2][AN3][AN4];
+    char tname[] = "distrwgt42";
+
+    erri = ER;
+
+    A4 = malloc(AN1 * AN2 * AN3 * AN4 * sizeof(int));
+    #pragma dvm redistribute(A4[wgtblock(wb, 6)][*][wgtblock(wb, 6)][*])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        A4[i][j][k][n] = i*NL/10+j*NL/100+k*NL/1000+n;
+    }
+
+    #pragma dvm redistribute(A4[*][wgtblock(wb, 6)][wgtblock(wb, 6)][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        if (A4[i][j][k][n] != i*NL/10+j*NL/100+k*NL/1000+n)
+                            erri = Min(erri, i*NL/10+j*NL/100+k*NL/1000+n);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A4);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/DISTR_WGT/distrwgt3.cdv

@@ -0,0 +1,478 @@
+/*    DISTRWGT3
+    Testing DISTRIBUTE and REDISTRIBUTE directives
+            WGT_BLOCK distribution*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void distrwgt39();
+static void distrwgt310();
+static void distrwgt311();
+static void distrwgt312();
+static void distrwgt313();
+static void distrwgt314();
+static void distrwgt315();
+static void distrwgt41();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, k, ia, ib, n;
+
+int main(int an, char **as)
+{
+    printf("=== START OF DISTRWGT3 ===================\n");
+    /* 39 DISTRIBUTE arrA3[BLOCK][BLOCK][BLOCK]
+                REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]*/
+    distrwgt39();
+    /* 310 DISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]
+                REDISTRIBUTE [BLOCK][BLOCK][BLOCK]*/
+    distrwgt310();
+    /* 311  DISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]
+                REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK][WGT_BLOCK] other weigths*/
+    distrwgt311();
+    /* 312 DISTRIBUTE arrA2[WGT_BLOCK][BLOCK][WGT_BLOCK]
+                REDISTRIBUTE arrA3[BLOCK][WGT_BLOCK][BLOCK]*/
+    distrwgt312();
+    /* 313 DISTRIBUTE arrA3[BLOCK][WGT_BLOCK][BLOCK]
+                REDISTRIBUTE arrA3[WGT_BLOCK][BLOCK][WGT_BLOCK]*/
+    distrwgt313();
+    /* 314 DISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]
+                REDISTRIBUTE arrA2[*][*][*]*/
+    distrwgt314();
+    /* 315  DISTRIBUTE arrA3[*][*][*]
+                REDISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]*/
+    distrwgt315();
+    /* 41  DISTRIBUTE arrA4[WGT_BLOCK][*][WGT_BLOCK][WGT_BLOCK]
+                REDISTRIBUTE arrA4[BLOCK][WGT_BLOCK][BLOCK][*]*/
+    distrwgt41();
+
+    printf("=== END OF DISTRWGT3 =====================\n");
+    return 0;
+}
+
+/* ---------------------------------------------DISTR39*/
+/* DISTRIBUTE arrA3[BLOCK][BLOCK][BLOCK]
+                REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]*/
+void distrwgt39()
+{
+    #define AN1 16
+    #define AN2 16
+    #define AN3 16
+    double wb1[6] = {3.0, 1., 2., 2.0, 2.5, 1.2};
+    double wb2[7] = {1., 3., 4.0, 1., 2., 2., 4.};
+    double wb3[6] = {5.0, 1., 3., 6.0, 2., 4.};
+    #pragma dvm array distribute[block][block][block]
+
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt39";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[wgtblock(wb1, 6)][wgtblock(wb2, 7)][wgtblock(wb3, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR310*/
+/* DISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]
+                REDISTRIBUTE [BLOCK][BLOCK][BLOCK]*/
+void distrwgt310()
+{
+    #define AN1 12
+    #define AN2 12
+    #define AN3 24
+    double wb1[6] = {2.0, 1., 1., 3.0, 2., 1.};
+    double wb2[8] = {1.0, 1., 2., 2.0, 1., 1., 2., 2.};
+    double wb3[6] = {2.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt310";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb1, 6)][wgtblock(wb2, 8)][wgtblock(wb3, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[block][block][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR311*/
+/* DISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]
+                REDISTRIBUTE [WGT_BLOCK][WGT_BLOCK][WGT_BLOCK] other weigths*/
+void distrwgt311()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    double wb1[6] = {2.0, 1., 1., 3.0, 2., 1.};
+    double wb2[8] = {1.0, 1., 2., 2.0, 1., 1., 2., 2.};
+    double wb3[6] = {2.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt311";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb1, 6)][wgtblock(wb2, 6)][wgtblock(wb3, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[wgtblock(wb3, 6)][wgtblock(wb1, 6)][wgtblock(wb2, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR312*/
+/* DISTRIBUTE arrA3[WGT_BLOCK][BLOCK][WGT_BLOCK]
+                REDISTRIBUTE arrA3[BLOCK][WGT_BLOCK][BLOCK]*/
+void distrwgt312()
+{
+    #define AN1 10
+    #define AN2 10
+    #define AN3 30
+    double wb1[6] = {2.0, 1., 1., 3.0, 2., 1.};
+    double wb2[8] = {1.0, 1., 2., 2.0, 1., 1., 2., 2.};
+    double wb3[6] = {2.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt312";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb1, 6)][block][wgtblock(wb3, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[block][wgtblock(wb2, 8)][block])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR313*/
+/* DISTRIBUTE arrA3[BLOCK][WGT_BLOCK][BLOCK]
+                REDISTRIBUTE arrA3[WGT_BLOCK][BLOCK][WGT_BLOCK]*/
+void distrwgt313()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    double wb1[6] = {2.0, 1., 1., 3.0, 2., 1.};
+    double wb2[8] = {1.0, 1., 2., 2.0, 1., 1., 2., 2.};
+    double wb3[6] = {2.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt313";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[block][wgtblock(wb2, 8)][block])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[wgtblock(wb1, 6)][block][wgtblock(wb3, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR314*/
+/* DISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]
+                REDISTRIBUTE arrA3[*][*][*]*/
+void distrwgt314()
+{
+    #define AN1 8
+    #define AN2 12
+    #define AN3 24
+    double wb1[6] = {2.0, 1., 1., 3.0, 2., 1.};
+    double wb2[8] = {1.0, 1., 2., 2.0, 1., 1., 2., 2.};
+    double wb3[6] = {2.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt314";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+    #pragma dvm redistribute(A3[wgtblock(wb1, 6)][wgtblock(wb2, 8)][wgtblock(wb3, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[*][*][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR315*/
+/*  DISTRIBUTE arrA3[*][*][*]
+                REDISTRIBUTE arrA3[WGT_BLOCK][WGT_BLOCK][WGT_BLOCK]*/
+void distrwgt315()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    double wb1[6] = {2.0, 1., 1., 3.0, 2., 1.};
+    double wb2[8] = {1.0, 1., 2., 2.0, 1., 1., 2., 2.};
+    double wb3[6] = {2.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array distribute[*][*][*]
+    int (*A3)[AN2][AN3];
+    char tname[] = "distrwgt315";
+
+    erri = ER;
+
+    A3 = malloc(AN1 * AN2 * AN3 * sizeof(int));
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    A3[i][j][k] = i*NL/10 + j*NL/100 + k;
+    }
+
+    #pragma dvm redistribute(A3[wgtblock(wb1, 6)][wgtblock(wb2, 8)][wgtblock(wb3, 6)])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k] on A3[i][j][k]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    if (A3[i][j][k] != i*NL/10 + j*NL/100 + k)
+                        erri = Min(erri, i*NL/10 + j*NL/100 + k);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A3);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------DISTR41*/
+/*DISTRIBUTE arrA4[WGT_BLOCK][*][WGT_BLOCK][WGT_BLOCK]
+                REDISTRIBUTE arrA4[BLOCK][WGT_BLOCK][BLOCK][*]*/
+void distrwgt41()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    #define AN4 8
+    double wb1[6] = {2.0, 1., 1., 3.0, 2., 1.};
+    double wb2[8] = {1.0, 1., 2., 2.0, 1., 1., 2., 2.};
+    double wb3[6] = {2.0, 2., 2., 3.0, 1., 1.};
+    #pragma dvm array
+    int (*A4)[AN2][AN3][AN4];
+    char tname[] = "distrwgt41";
+
+    erri = ER;
+
+    A4 = malloc(AN1 * AN2 * AN3 * AN4 * sizeof(int));
+    #pragma dvm redistribute(A4[wgtblock(wb1, 6)][*][wgtblock(wb2, 8)][wgtblock(wb3, 6)])
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        A4[i][j][k][n] = i*NL/10+j*NL/100+k*NL/1000+n;
+    }
+
+    #pragma dvm redistribute(A4[block][wgtblock(wb3, 6)][block][*])
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i][j][k][n] on A4[i][j][k][n]) reduction(min(erri)), cuda_block(256)
+        for (i = 0; i < AN1; i++)
+            for (j = 0; j < AN2; j++)
+                for (k = 0; k < AN3; k++)
+                    for (n = 0; n < AN4; n++)
+                        if (A4[i][j][k][n] != i*NL/10+j*NL/100+k*NL/1000+n)
+                            erri = Min(erri, i*NL/10+j*NL/100+k*NL/1000+n);
+    }
+
+    #pragma dvm get_actual(erri)
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+    free(A4);
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fopen11.cdv

@@ -0,0 +1,181 @@
+
+/*      TESTING OF THE function fopen        
+        FOR DISTRIBUTED ARRAY A[N].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define NL 1000
+
+static void fop1101();
+static void fop1102();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START TFOPEN11========================\n");
+      fop1101();
+      fop1102();
+
+      printf("=== END OF TFOPEN11 ========================= \n");
+      return 0;
+}
+/* -------------------------------------------------fop1101  */
+      void fop1101()
+{
+
+
+      char tname[]="FOPEN_1101";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+          B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARFOP01_%04d.txt", "wl"))==NULL) {
+     printf("ERROR OPENING FILE ARFOP01_%%4d.txt \n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++) {
+       #pragma dvm remote_access(A[i])
+        {  
+         na=A[i];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+     fclose(fp);
+     
+     if ((fp=fopen("ARFOP01_%04d.txt", "rl"))==NULL) {
+     printf("ERROR OPENING FILE ARFOP_%%4d.txt \n");
+     exit(1);
+     }
+//     rewind(fp);
+       
+      for (i=0;i<=N-1;i++)
+      {
+      ni=fscanf(fp, "%d ",&nb);
+      B[i]=nb;
+      }      
+     fclose(fp);
+     dvmh_remove_local("ARFOP01_%04d.txt");
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+/* -------------------------------------------------fop1102  */
+      void fop1102()
+{
+
+
+      char tname[]="FOPEN_1102";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+      #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+          B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARFOP02.txt", "wp"))==NULL) {
+     printf("ERROR OPENING FILE ARFOP02.txt \n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++) {
+       #pragma dvm remote_access(A[i])
+        {  
+         na=A[i];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+     fclose(fp);
+     
+     if ((fp=fopen("ARFOP02.txt", "rp"))==NULL) {
+     printf("ERROR OPENING FILE ARFOP02.txt \n");
+     exit(1);
+     }
+//     rewind(fp);
+       
+      for (i=0;i<=N-1;i++)
+      {
+      ni=fscanf(fp, "%d ",&nb);
+      B[i]=nb;
+      }      
+     fclose(fp);
+     remove("ARFOP02.txt");
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fpsc11.cdv

@@ -0,0 +1,105 @@
+
+/*      TESTING OF THE function fprintf and fscanf       
+        FOR DISTRIBUTED ARRAY A[N].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define NL 1000
+static void prsc1101();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fpsc11========================\n");
+      prsc1101();
+
+      printf("=== END OF fpsc11 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------prsc1101  */
+      void prsc1101()
+{
+
+
+      char tname[]="FPRINT_FSCANF_1101";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+      #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+          B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARFPSC11", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARFPSC11\n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++) {
+       #pragma dvm remote_access(A[i])
+        {  
+         na=A[i];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+     fclose(fp);
+     
+     if ((fp=fopen("ARFPSC11", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARFPSC11\n");
+     exit(1);
+     }
+//     rewind(fp);
+       
+      for (i=0;i<=N-1;i++)
+      {
+      ni=fscanf(fp, "%d ",&nb);
+      B[i]=nb;
+      }      
+     fclose(fp);
+     remove("ARFPSC11");                
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fpsc12.cdv

@@ -0,0 +1,105 @@
+
+/*      TESTING OF THE function fprintf and fscanf       
+        FOR DISTRIBUTED ARRAY A[N].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define NL 1000
+static void prsc1201();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fpsc12========================\n");
+      prsc1201();
+
+      printf("=== END OF fpsc12 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------prsc1201  */
+      void prsc1201()
+{
+
+
+      char tname[]="FPRINT_FSCANF_1201";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[*]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+           B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARFPSC12", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARFPSC12\n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++) {
+       #pragma dvm remote_access(A[i])
+        {  
+         na=A[i];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+     fclose(fp);
+     
+     if ((fp=fopen("ARFPSC12", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARFPSC12\n");
+     exit(1);
+     }
+//     rewind(fp);
+       
+      for (i=0;i<=N-1;i++)
+      {
+      ni=fscanf(fp, "%d ",&nb);
+      B[i]=nb;
+      }      
+     fclose(fp);
+     remove("ARFPSC12");                
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fpsc21.cdv

@@ -0,0 +1,112 @@
+
+/*      TESTING OF THE function fprintf and fscanf       
+        FOR DISTRIBUTED ARRAY A[N][M].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define M 4
+#define NL 1000
+static void prsc2101();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fpsc21========================\n");
+      prsc2101();
+
+      printf("=== END OF fpsc21 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------prsc2101  */
+      void prsc2101()
+{
+
+
+      char tname[]="FPRINT_FSCANF_2101";
+      int i,j,nloopi,nloopj,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][block]          
+      int A[N][M];
+      #pragma dvm array align ([i][j] with A[i][j])
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARFPSC21", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARFPSC21 \n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+       {
+       #pragma dvm remote_access(A[i][j])
+        {  
+         na=A[i][j];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+     fclose(fp);
+     
+     if ((fp=fopen("ARFPSC21", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARFPSC21 \n");
+     exit(1);
+     }
+//     rewind(fp);
+       
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+      {
+      ni=fscanf(fp, "%d ",&nb);
+      B[i][j]=nb;
+      }      
+     fclose(fp);
+     remove("ARFPSC21");                    
+    #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fpsc22.cdv

@@ -0,0 +1,112 @@
+
+/*      TESTING OF THE function fprintf and fscanf       
+        FOR DISTRIBUTED ARRAY A[N][M].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define M 4
+#define NL 1000
+static void prsc2201();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fpsc22========================\n");
+      prsc2201();
+
+      printf("=== END OF fpsc22 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------prsc2201  */
+      void prsc2201()
+{
+
+
+      char tname[]="FPRINT_FSCANF_2201";
+      int i,j,nloopi,nloopj,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[*][block]          
+      int A[N][M];
+      #pragma dvm array align ([i][j] with A[i][j])
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARFPSC22", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARFPSC22 \n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+       {
+       #pragma dvm remote_access(A[i][j])
+        {  
+         na=A[i][j];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+     fclose(fp);
+     
+     if ((fp=fopen("ARFPSC22", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARFPSC22 \n");
+     exit(1);
+     }
+//     rewind(fp);
+       
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+      {
+      ni=fscanf(fp, "%d ",&nb);
+      B[i][j]=nb;
+      }      
+     fclose(fp);
+     remove("ARFPSC22");                    
+    #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fwrre11.cdv

@@ -0,0 +1,236 @@
+
+/*      TESTING OF THE function fwrite and fread       
+        FOR DISTRIBUTED ARRAY A[N].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define NL 1000
+static void wrre1101();
+static void wrre1102();
+static void wrre1103();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fwrre11========================\n");
+      wrre1101();
+      wrre1102();
+      wrre1103();
+
+      printf("=== END OF fwrre11 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------wrre1101  */
+      void wrre1101()
+{
+
+
+      char tname[]="FWRITE_FREAD_1101";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+           B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE01", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01\n");
+     exit(1);
+     }
+
+     if (fwrite(A, sizeof(int), N, fp)!=N)
+     printf("ERROR WRITING FILE ARWRRE01\n");
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE01", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01 \n");
+     exit(1);
+     }
+//     rewind(fp);
+     if (fread(B, sizeof(int), N, fp)!=N)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+     remove("ARWRRE01");
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+/* ---------------------------------------------wrre1102  */
+      void wrre1102()
+{
+
+
+      char tname[]="FWRITE_FREAD_1102";
+      int i,nloopi,ni,nb,na,K;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+           B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE02_%04d", "wbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE02_%04d", "rbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     dvmh_remove_local("ARWRRE02_%04d");
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+/* ---------------------------------------------wrre1103  */
+      void wrre1103()
+{
+
+
+      char tname[]="FWRITE_FREAD_1103";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+           B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE03", "wbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01\n");
+     exit(1);
+     }
+
+     if (fwrite(A, sizeof(int), N, fp)!=N)
+     printf("ERROR WRITING FILE ARWRRE01\n");
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE03", "rbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01 \n");
+     exit(1);
+     }
+//     rewind(fp);
+     if (fread(B, sizeof(int), N, fp)!=N)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+     remove("ARWRRE03");
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fwrre12.cdv

@@ -0,0 +1,236 @@
+
+/*      TESTING OF THE function fwrite and fread       
+        FOR LOCAL ARRAY A[N].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define NL 1000
+static void wrre1201();
+static void wrre1202();
+static void wrre1203();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fwrre12========================\n");
+      wrre1201();
+      wrre1202();
+      wrre1203();
+
+      printf("=== END OF fwrre12 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------wrre1201  */
+      void wrre1201()
+{
+
+
+      char tname[]="FWRITE_FREAD_1201";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[*]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+           B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE01", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01\n");
+     exit(1);
+     }
+
+     if (fwrite(A, sizeof(int), N, fp)!=N)
+     printf("ERROR WRITING FILE ARWRRE01\n");
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE01", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01 \n");
+     exit(1);
+     }
+//     rewind(fp);
+     if (fread(B, sizeof(int), N, fp)!=N)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+     remove("ARWRRE01");
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+/* ---------------------------------------------wrre1202  */
+      void wrre1202()
+{
+
+
+      char tname[]="FWRITE_FREAD_1202";
+      int i,nloopi,ni,nb,na,K;
+      FILE *fp;
+                
+      #pragma dvm array distribute[*]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+          B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE02_%04d", "wbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE02_%04d", "rbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     dvmh_remove_local("ARWRRE02_%04d");
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+/* ---------------------------------------------wrre1203  */
+      void wrre1203()
+{
+
+
+      char tname[]="FWRITE_FREAD_1203";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[*]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+          B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE03", "wbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01\n");
+     exit(1);
+     }
+
+     if (fwrite(A, sizeof(int), N, fp)!=N)
+     printf("ERROR WRITING FILE ARWRRE01\n");
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE03", "rbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01 \n");
+     exit(1);
+     }
+//     rewind(fp);
+     if (fread(B, sizeof(int), N, fp)!=N)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+     remove("ARWRRE03");
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fwrre21.cdv

@@ -0,0 +1,242 @@
+
+/*      TESTING OF THE function fwrite and fread       
+        FOR DISTRIBUTED ARRAY A[N][M].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define M 16
+#define NL 1000
+static void wrre2101();
+static void wrre2102();
+static void wrre2103();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fwrre21========================\n");
+      wrre2101();
+      wrre2102();
+      wrre2103();
+
+      printf("=== END OF fwrre21 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------wrre2101  */
+      void wrre2101()
+{
+
+
+      char tname[]="FWRITE_FREAD_2101";
+      int i,j,nloopi,nloopj,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][block]          
+      int A[N][M];
+      #pragma dvm array align ([i][j] with A[i][j])
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE01", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01\n");
+     exit(1);
+     }
+
+     if (fwrite(A, sizeof(int), N*M, fp)!=N*M)
+     printf("ERROR WRITING FILE ARWRRE01\n");
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE01", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01 \n");
+     exit(1);
+     }
+//     rewind(fp);
+     if (fread(B, sizeof(int), N*M, fp)!=N*M)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+     remove("ARWRRE01");
+                    
+     #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi),min(nloopj))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+/* ---------------------------------------------wrre2102  */
+      void wrre2102()
+{
+
+
+      char tname[]="FWRITE_FREAD_2102";
+      int i,j,nloopi,nloopj,ni,nb,na,K;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][block]          
+      int A[N][M];
+      #pragma dvm array align ([i][j] with A[i][j])
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE02_%04d", "wbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N*M, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE02_%04d", "rbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N*M, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     dvmh_remove_local("ARWRRE02_%04d");
+                    
+    #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+/* ---------------------------------------------wrre2103  */
+      void wrre2103()
+{
+
+
+      char tname[]="FWRITE_FREAD_2103";
+      int i,j,nloopi,nloopj,ni,nb,na,K;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][block]          
+      int A[N][M];
+      #pragma dvm array align ([i][j] with A[i][j])
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+      #pragma dvm region out(A) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE03_%04d", "wbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE03_%%04d\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N*M, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE03_%04d", "rbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N*M, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     remove("ARWRRE03_%04d");
+                    
+    #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fwrre22.cdv

@@ -0,0 +1,242 @@
+
+/*      TESTING OF THE function fwrite and fread       
+        FOR DISTRIBUTED ARRAY A[N][M].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define M 16
+#define NL 1000
+static void wrre2201();
+static void wrre2202();
+static void wrre2203();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fwrre22========================\n");
+      wrre2201();
+      wrre2202();
+      wrre2203();
+
+      printf("=== END OF fwrre22 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------wrre2201  */
+      void wrre2201()
+{
+
+
+      char tname[]="FWRITE_FREAD_2201";
+      int i,j,nloopi,nloopj,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][*]          
+      int A[N][M];
+      #pragma dvm array align ([i][j] with A[i][j])
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE01", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01\n");
+     exit(1);
+     }
+
+     if (fwrite(A, sizeof(int), N*M, fp)!=N*M)
+     printf("ERROR WRITING FILE ARWRRE01\n");
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE01", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01 \n");
+     exit(1);
+     }
+//     rewind(fp);
+     if (fread(B, sizeof(int), N*M, fp)!=N*M)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+     remove("ARWRRE01");
+                    
+     #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi),min(nloopj))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+/* ---------------------------------------------wrre2202  */
+      void wrre2202()
+{
+
+
+      char tname[]="FWRITE_FREAD_2202";
+      int i,j,nloopi,nloopj,ni,nb,na,K;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][*]          
+      int A[N][M];
+      #pragma dvm array align ([i][j] with A[i][j])
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE02_%04d", "wbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N*M, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE02_%04d", "rbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N*M, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     dvmh_remove_local("ARWRRE02_%04d");
+                    
+    #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+/* ---------------------------------------------wrre2203  */
+      void wrre2203()
+{
+
+
+      char tname[]="FWRITE_FREAD_2203";
+      int i,j,nloopi,nloopj,ni,nb,na,K;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][*]          
+      int A[N][M];
+      #pragma dvm array align ([i][j] with A[i][j])
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE03_%04d", "wbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE03_%%04d\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N*M, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE03_%04d", "rbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N*M, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     remove("ARWRRE03_%04d");
+                    
+    #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fwrre23.cdv

@@ -0,0 +1,242 @@
+
+/*      TESTING OF THE function fwrite and fread       
+        FOR DISTRIBUTED ARRAY A[N][M] AND LOCAL B[N][M].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define M 16
+#define NL 1000
+static void wrre2301();
+static void wrre2302();
+static void wrre2303();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fwrre23========================\n");
+      wrre2301();
+      wrre2302();
+      wrre2303();
+
+      printf("=== END OF fwrre23 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------wrre2301  */
+      void wrre2301()
+{
+
+
+      char tname[]="FWRITE_FREAD_2301";
+      int i,j,nloopi,nloopj,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][block]          
+      int A[N][M];
+      #pragma dvm array distribute[*][*]
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE01", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01\n");
+     exit(1);
+     }
+
+     if (fwrite(A, sizeof(int), N*M, fp)!=N*M)
+     printf("ERROR WRITING FILE ARWRRE01\n");
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE01", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01 \n");
+     exit(1);
+     }
+//     rewind(fp);
+     if (fread(B, sizeof(int), N*M, fp)!=N*M)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+     remove("ARWRRE01");
+                    
+     #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi),min(nloopj))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+/* ---------------------------------------------wrre2302  */
+      void wrre2302()
+{
+
+
+      char tname[]="FWRITE_FREAD_2302";
+      int i,j,nloopi,nloopj,ni,nb,na,K;
+      FILE *fp;
+                
+      #pragma dvm array distribute[*][*]          
+      int A[N][M];
+      #pragma dvm array distribute[*][*]          
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE02_%04d", "wbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N*M, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE02_%04d", "rbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N*M, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     dvmh_remove_local("ARWRRE02_%04d");
+                    
+    #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+/* ---------------------------------------------wrre2303  */
+      void wrre2303()
+{
+
+
+      char tname[]="FWRITE_FREAD_2303";
+      int i,j,nloopi,nloopj,ni,nb,na,K;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][block]          
+      int A[N][M];
+      #pragma dvm array distribute[*][*]          
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE03_%04d", "wbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE03_%%04d\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N*M, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE03_%04d", "rbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N*M, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     remove("ARWRRE03_%04d");
+                    
+    #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/fwrre24.cdv

@@ -0,0 +1,297 @@
+
+/*      TESTING OF THE function fwrite and fread       
+        FOR DISTRIBUTED ARRAY A[N][M] AND B[N][M].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define M 16
+#define NL 1000
+static void wrre2401();
+static void wrre2402();
+static void wrre2403();
+static void wrre2404();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START fwrre24========================\n");
+      wrre2401();
+      wrre2402();
+      wrre2403();
+      wrre2404();
+
+      printf("=== END OF fwrre24 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------wrre2401  */
+      void wrre2401()
+{
+
+
+      char tname[]="FWRITE_FREAD_2401";
+      int i,j,nloopi,nloopj,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][block]          
+      int A[N][M];
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE01", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01\n");
+     exit(1);
+     }
+
+     if (fwrite(A, sizeof(int), N*M, fp)!=N*M)
+     printf("ERROR WRITING FILE ARWRRE01\n");
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE01", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE01 \n");
+     exit(1);
+     }
+//     rewind(fp);
+     if (fread(B, sizeof(int), N*M, fp)!=N*M)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+     remove("ARWRRE01");
+                    
+     #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi),min(nloopj))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+/* ---------------------------------------------wrre2402  */
+      void wrre2402()
+{
+
+
+      char tname[]="FWRITE_FREAD_2402";
+      int i,j,nloopi,nloopj,ni,nb,na,K;
+      FILE *fp;
+                
+      int A[N][M];
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+        }
+
+     if((fp=fopen("ARWRRE02_%04d", "wbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N*M, fp);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE02_%04d", "rbl"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE02_%%04d\n");
+     exit(1);
+     }
+     K=fread(B, sizeof(int), N*M, fp);
+     fclose(fp);
+     dvmh_remove_local("ARWRRE02_%04d");
+                    
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+/* ---------------------------------------------wrre2403  */
+      void wrre2403()
+{
+
+
+      char tname[]="FWRITE_FREAD_2403";
+      int i,j,nloopi,nloopj,ni,nb,na,K;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block][block]          
+      int A[N][M];
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on A[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+        {  A[i][j] = NL+i+j;
+           B[i][j]=777;
+
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE03", "wbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE03\n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N*M, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE03", "rbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE03\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N*M, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     remove("ARWRRE03");
+                    
+    #pragma dvm parallel ([i][j] on A[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (A[i][j] !=B[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+/* ---------------------------------------------wrre2404  */
+      void wrre2404()
+{
+
+
+      char tname[]="FWRITE_FREAD_2404";
+      int i,j,nloopi,nloopj,ni,nb,na,K;
+      FILE *fp;
+                
+      int A[N][M];
+      #pragma dvm array distribute[block][block]          
+      int B[N][M];
+
+
+
+      nloopi=NL;
+      nloopj=NL;
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i][j] on B[i][j])
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+           B[i][j]=777;
+
+      } /*end region*/ 
+      for (i=0;i<=N-1;i++)
+          for(j=0;j<=M-1;j++)
+          A[i][j]=NL+i+j; 
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARWRRE04", "wbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE04 \n");
+     exit(1);
+     }
+
+     K=fwrite(A, sizeof(int), N*M, fp);
+//     printf("NUMBER=%d\n",K);
+     fclose(fp);
+     
+     if ((fp=fopen("ARWRRE04", "rbp"))==NULL) {
+     printf("ERROR OPENING FILE ARWRRE04\n");
+     exit(1);
+     }
+//     rewind(fp);
+     K=fread(B, sizeof(int), N*M, fp);
+//     printf("NUMBER1=%d\n",K);
+     fclose(fp);
+     remove("ARWRRE04");
+                    
+    #pragma dvm parallel ([i][j] on B[i][j])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          for (j=0;j<=M-1;j++)
+              if (B[i][j] !=A[i][j]) 
+            {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/remove11.cdv

@@ -0,0 +1,85 @@
+
+/*      TESTING OF THE function remove        
+        FOR FILEs.  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define NL 1000
+static void remove1101();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START REMOVE11========================\n");
+      remove1101();
+
+      printf("=== END OF TREMOVE11 ========================= \n");
+      return 0;
+}
+/* -------------------------------------------------remove1101  */
+      void remove1101()
+{
+
+
+      char tname[]="REMOVE_1101";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+           B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARREMOVE_1101", "wl"))==NULL) {
+     printf("ERROR OPENING FILE ARREMOVE_1101 \n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++) {
+       #pragma dvm remote_access(A[i])
+        {  
+         na=A[i];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+     fclose(fp);
+     if (remove("ARREMOVE_1101"))
+        ansno(tname);
+    else
+        ansyes(tname);
+
+      return ;
+
+   
+}
+      
+
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/rename11.cdv

@@ -0,0 +1,182 @@
+
+/*      TESTING OF THE function rename       
+        FOR DISTRIBUTED ARRAY A[N].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define NL 1000
+static void rename1101();
+static void rename1102();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+      printf("===START TRENAME11============================ \n");
+      rename1101();
+      rename1102();
+      printf("=== END OF TRENAME11 ========================= \n");
+      return 0;
+}
+/* ---------------------------------------------rename1101  */
+      void rename1101()
+{
+
+
+      char tname[]="RENAME_1101";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+           B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARRENAMEA", "wb"))==NULL) {
+     printf("ERROR OPENING FILE ARRENAMEA\n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++) {
+       #pragma dvm remote_access(A[i])
+        {  
+         na=A[i];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+     fclose(fp);
+     if(rename("ARRENAMEA", "ARRENAMEB") != 0)
+     printf("ERROR WHEN RENAMING =>,ARRENAMEA,ARRENAMEB\n");
+     if ((fp=fopen("ARRENAMEB", "rb"))==NULL) {
+     printf("ERROR OPENING FILE ARRENAMEB \n");
+     exit(1);
+     }
+//     rewind(fp);
+       
+      for (i=0;i<=N-1;i++)
+      {
+      ni=fscanf(fp, "%d ",&nb);
+      B[i]=nb;
+      }      
+     fclose(fp);
+     remove("ARRENAMEB");                
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+/* -------------------------------------------------rename1102  */
+      void rename1102()
+{
+
+
+      char tname[]="RENAME_1102";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+      #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+          B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=fopen("ARRENAMEA2_%04d.txt", "wl"))==NULL) {
+     printf("ERROR OPENING FILE ARRENAMEA2.txt \n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++) {
+       #pragma dvm remote_access(A[i])
+        {  
+         na=A[i];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+     fclose(fp);
+
+     if (dvmh_rename_local("ARRENAMEA2_%04d.txt", "ARRENAMEB2_%04d.txt") !=0)
+     printf("ERROR WHEN RENAMING =>,ARRENAMEA2,ARRENAMEB2\n");
+     
+     if ((fp=fopen("ARRENAMEB2_%04d.txt", "rl"))==NULL) {
+     printf("ERROR OPENING FILE ARRENAMEB2.txt \n");
+     exit(1);
+     }
+//     rewind(fp);
+       
+      for (i=0;i<=N-1;i++)
+      {
+      ni=fscanf(fp, "%d ",&nb);
+      B[i]=nb;
+      }      
+     fclose(fp);
+     dvmh_remove_local("ARRENAMEB2_%04d.txt");
+               
+     #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/IO/tmpfile11.cdv

@@ -0,0 +1,225 @@
+
+/*      TESTING OF THE function tmpfile        
+        FOR DISTRIBUTED ARRAY A[N].  
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define N 8
+#define NL 1000
+
+static void tmpfile1101();
+static void tmpfile1102();
+static void tmpfile1103();
+
+static void ansyes(char tname[]);
+static void ansno(char tname[]);
+
+int main(int argc, char *argv[])
+{
+   printf("===START TMPFILE11========================\n");
+      tmpfile1101();
+      tmpfile1102();
+      tmpfile1103();
+
+      printf("=== END OF TMPFILE11 ========================= \n");
+      return 0;
+}
+/* -------------------------------------------------tmpfile1101  */
+      void tmpfile1101()
+{
+
+
+      char tname[]="TMPFILE_1101";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+    #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+           B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=tmpfile())==NULL) {
+     printf("ERROR OPENING TMPFILE01 \n");
+     exit(1);
+     }
+        for (i=0;i<=N-1;i++) {
+       #pragma dvm remote_access(A[i])
+        {  
+         na=A[i];
+        }   
+        ni=fprintf(fp, "%d ", na);  
+        }
+      rewind(fp); 
+      for (i=0;i<=N-1;i++)
+      {
+      ni=fscanf(fp, "%d ",&nb);
+      B[i]=nb;
+      }      
+     fclose(fp);
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+
+   
+/* ---------------------------------------------tmpfile1102  */
+      void tmpfile1102()
+{
+
+
+      char tname[]="TMPFILE_1102";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+      #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+          B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+     if((fp=tmpfile())==NULL) {
+     printf("ERROR OPENING TMPFILE02 \n");
+     exit(1);
+     }
+
+     if (fwrite(A, sizeof(int), N, fp)!=N)
+     printf("ERROR WRITING FILE TMPFILE02\n");
+     rewind(fp);
+     
+     if (fread(B, sizeof(int), N, fp)!=N)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+/* ---------------------------------------------tmpfile1103  */
+      void tmpfile1103()
+{
+
+
+      char tname[]="TMPFILE_1103";
+      int i,nloopi,ni,nb,na;
+      FILE *fp;
+                
+      #pragma dvm array distribute[block]          
+      int A[N];
+      #pragma dvm array align ([i] with A[i])
+      int B[N];
+
+
+
+      nloopi=NL;
+
+      #pragma dvm region out(A,B) 
+      {
+      #pragma dvm parallel ([i] on A[i])
+      for (i=0;i<=N-1;i++)
+        {  A[i] = NL+i;
+          B[i]=777;
+        }
+      } /*end region*/  
+
+      #pragma dvm get_actual(A,B) 
+
+      fp=dvmh_tmpfile_local();
+
+     if (fwrite(A, sizeof(int), N, fp)!=N)
+     printf("ERROR WRITING FILE TMPFILE02\n");
+     rewind(fp);
+     
+     if (fread(B, sizeof(int), N, fp)!=N)
+        {
+        if(feof(fp)) printf("PREMATURE END OF FILE ARWRRE01");
+        else printf("ERROR READING FILE ARWRRE01\n");
+  }
+     fclose(fp);
+                    
+    #pragma dvm parallel ([i] on A[i])  reduction(min(nloopi))
+      for (i=0;i<=N-1;i++)
+          {
+              if (A[i] !=B[i]) 
+                if (nloopi > i) nloopi = i;
+          }
+//    printf ("nloopi=%d\n", nloopi);
+    if (nloopi == NL )
+        ansyes(tname);
+    else
+        ansno(tname);
+
+      return ;
+
+   
+}
+      
+
+void ansyes(char name[])
+{
+      printf ("%s  -  complete\n",name);
+    return ;
+}
+      void ansno(char name[])
+{
+     printf("%s  -  ***error\n",name);
+      return ;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/OWNCALC/owncal11.cdv

@@ -0,0 +1,285 @@
+/*      TESTING OF THE OWN CALCULASHION
+        FOR DISTRIBUTED ARRAY A[N].
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define N 32
+#define NL 1000
+
+static void owncal1101();
+static void owncal1102();
+static void owncal1103();
+static void owncal1104();
+static void owncal1105();
+static void owncal1106();
+
+static void serial(int AR[], int NN, int NNL);
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+int main(int argc, char *argv[])
+{
+    printf("===START OF OWNCAL11========================\n");
+    owncal1101();
+    owncal1102();
+    owncal1103();
+    owncal1104();
+    owncal1105();
+    owncal1106();
+
+    printf("=== END OF OWNCAL11 ========================= \n");
+    return 0;
+}
+/* ---------------------------------------------OWNCAL1101  */
+void owncal1101()
+{
+    int C[N];
+    char tname[] = "OWN1101";
+    int i, NN, NNL, nloopi;
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    NN = N;
+    NNL = NL;
+
+    serial(C, NN, NNL);
+
+    nloopi = NL;
+
+    #pragma dvm region out(A)
+    {
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloopi))
+    for (i = 1; i < N - 1; i++)
+        if (A[i] != C[i])
+            if (nloopi > i) nloopi = i;
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL1102  */
+void owncal1102()
+{
+    int C[N];
+    char tname[] = "OWN1102";
+    int i, NN, NNL, nloopi;
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    NN = N;
+    NNL = NL;
+
+    serial(C, NN, NNL);
+    C[0] = N + NL + 2;
+
+    nloopi = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    A[0]=N+NL+2;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloopi))
+    for (i = 1; i < N - 1; i++)
+        if (A[i] != C[i])
+            if (nloopi > i) nloopi = i;
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL1103  */
+void owncal1103()
+{
+    int C[N];
+    char tname[] = "OWN1103";
+    int i, NN, NNL, nloopi, ni;
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    NN = N;
+    NNL = NL;
+
+    serial(C, NN, NNL);
+    ni = N / 2;
+    C[ni] = N + NL + 3;
+
+    nloopi = NL;
+    #pragma dvm actual(ni)
+
+    #pragma dvm region out(A), in(ni)
+    {
+    #pragma dvm parallel([i] on A[i])
+      for (i = 0; i < N; i++)
+          A[i] = NL + i;
+
+    A[ni] = N + NL + 3;
+
+    } /*end region*/
+
+      #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloopi))
+    for (i = 1; i < N - 1; i++)
+        if (A[i] != C[i])
+            if (nloopi > i) nloopi = i;
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL1104  */
+void owncal1104()
+{
+    int C[N];
+    char tname[] = "OWN1104";
+    int i, NN, NNL, nloopi, ni;
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    NN = N;
+    NNL = NL;
+
+    serial(C, NN, NNL);
+    ni = N / 2;
+    C[ni+1] = N + NL + 4;
+
+    nloopi = NL;
+
+    #pragma dvm region out(A), in(ni)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    A[ni + 1] = N + NL + 4;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloopi))
+    for (i = 1; i < N - 1; i++)
+        if (A[i] != C[i])
+            if (nloopi > i) nloopi = i;
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL1105  */
+void owncal1105()
+{
+    int C[N];
+    char tname[] = "OWN1105";
+    int i, NN, NNL, nloopi, ni;
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    NN = N;
+    NNL = NL;
+
+    serial(C, NN, NNL);
+    ni = N / 2;
+    C[ni - 1] = -(N + NL + 5);
+
+    nloopi = NL;
+
+    #pragma dvm region out(A), in(ni)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    A[ni - 1] = -(N + NL + 5);
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloopi))
+    for (i = 1; i < N - 1; i++)
+        if (A[i] != C[i])
+            if (nloopi > i) nloopi = i;
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL1106  */
+void owncal1106()
+{
+    int C[N];
+    char tname[] = "OWN1106";
+    int i, NN, NNL, nloopi, ni;
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    NN = N;
+    NNL = NL;
+
+    serial(C, NN, NNL);
+    C[N - 1] = N + NL + 6;
+
+    nloopi = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    A[N - 1] = N + NL + 1;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i] on A[i]) reduction(min(nloopi))
+    for (i = 1; i < N - 1; i++)
+        if (A[i] != C[i])
+            if (nloopi > i) nloopi = i;
+    if (nloopi == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+void serial(int AR[], int NN, int NNL)
+{
+    int i;
+    for (i = 0; i < NN; i++)
+        AR[i] = NNL+i;
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/OWNCALC/owncal21.cdv

@@ -0,0 +1,520 @@
+/*      TESTING OF THE OWN CALCULASHION
+        FOR DISTRIBUTED ARRAY A[N][M].
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define N 32
+#define M 32
+#define NL 1000
+
+static void owncal2101();
+static void owncal2102();
+static void owncal2103();
+static void owncal2104();
+static void owncal2105();
+static void owncal2106();
+static void owncal2107();
+static void owncal2108();
+static void owncal2109();
+static void owncal2110();
+
+static void serial2(int AR[][M], int NN, int NM, int NNL);
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+int main(int argc, char *argv[])
+{
+    printf("===START OF OWNCAL21========================\n");
+    owncal2101();
+    owncal2102();
+    owncal2103();
+    owncal2104();
+    owncal2105();
+    owncal2106();
+    owncal2107();
+    owncal2108();
+    owncal2109();
+    owncal2110();
+
+    printf("=== END OF OWNCAL21 ========================= \n");
+    return 0;
+}
+/* ---------------------------------------------OWNCAL2101  */
+void owncal2101()
+{
+    int C[N][M];
+    char tname[] = "OWN2101";
+    int i, j, NN, NM, NNL, nloopi, nloopj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+
+    nloopi = NL;
+    nloopj = NL;
+
+    #pragma dvm region out(A)
+    {
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL2102  */
+void owncal2102()
+{
+    int C[N][M];
+    char tname[] = "OWN2102";
+    int i, j, NN, NM, NNL, nloopi, nloopj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+    C[0][0] = N + M + NL + 1;
+
+    nloopi = NL;
+    nloopj = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[0][0] = N + M + NL + 1;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL2103  */
+void owncal2103()
+{
+    int C[N][M];
+    char tname[] = "OWN2103";
+    int i, j, NN, NM, NNL, nloopi, nloopj, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    C[ni][nj] = N + M + NL + 1;
+
+    nloopi = NL;
+    nloopj = NL;
+    #pragma dvm actual(ni,nj)
+
+    #pragma dvm region out(A), in(ni, nj)
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[ni][nj] = N + M + NL + 1;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL2104  */
+void owncal2104()
+{
+    int  C[N][M];
+    char tname[] = "OWN2104";
+    int i, j, NN, NM, NNL, nloopi, nloopj, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    C[ni + 1][nj + 1] = N + M + NL + 1;
+
+    nloopi = NL;
+    nloopj = NL;
+
+    #pragma dvm region out(A), in(ni, nj)
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[ni + 1][nj + 1] = N + M + NL + 1;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL2105  */
+void owncal2105()
+{
+    int C[N][M];
+    char tname[] = "OWN2105";
+    int i, j, NN, NM, NNL, nloopi, nloopj, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+    ni = N / 2;
+    nj = M / 2 ;
+    C[ni - 1][nj - 1] = -(N + M + NL + 1);
+
+    nloopi = NL;
+    nloopj = NL;
+
+    #pragma dvm region out(A), in(ni, nj)
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[ni - 1][nj - 1] = -(N + M + NL + 1);
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL2106  */
+void owncal2106()
+{
+    int C[N][M];
+    char tname[] = "OWN2106";
+    int i, j, NN, NM, NNL, nloopi, nloopj, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+    ni = N / 2;
+    nj = M / 2 ;
+    C[ni + 1][nj - 1] = N + M + NL + 1;
+
+    nloopi = NL;
+    nloopj = NL;
+
+    #pragma dvm region out(A), in(ni, nj)
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[ni + 1][nj - 1] = N + M + NL + 1;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL2107  */
+void owncal2107()
+{
+    int C[N][M];
+    char tname[] = "OWN2107";
+    int i, j, NN, NM, NNL, nloopi, nloopj, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+    ni = N / 2;
+    nj = M / 2 ;
+    C[ni - 1][nj + 1] = N + M + NL + 1;
+
+    nloopi = NL;
+    nloopj = NL;
+
+    #pragma dvm region out(A), in(ni, nj)
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[ni - 1][nj + 1] = N + M + NL + 1;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL2108  */
+void owncal2108()
+{
+    int C[N][M];
+    char tname[] = "OWN2108";
+    int i, j, NN, NM, NNL, nloopi, nloopj, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+
+    C[0][M - 1] = N + M + NL + 1;
+
+    nloopi = NL;
+    nloopj = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[0][M - 1] = N + M + NL + 1;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL2109  */
+      void owncal2109()
+{
+    int C[N][M];
+    char tname[] = "OWN2109";
+    int i, j, NN, NM, NNL, nloopi, nloopj, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+    C[N - 1][0] = N + M + NL + 1;
+
+    nloopi = NL;
+    nloopj = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[N - 1][0] = N + M + NL + 1;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL2110  */
+void owncal2110()
+{
+    int C[N][M];
+    char tname[] = "OWN2110";
+    int i, j, NN, NM, NNL, nloopi, nloopj, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    serial2(C, NN, NM, NNL);
+    nj = M / 2;
+    C[0][nj + 1] = N + M + NL + 1;
+
+    nloopi = NL;
+    nloopj = NL;
+
+    #pragma dvm region out(A), in(nj)
+    {
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[0][nj + 1] = N + M + NL + 1;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(nloopi), min(nloopj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            if (A[i][j] != C[i][j]) {
+                if (nloopi > i) nloopi = i;
+                if (nloopj > j) nloopj = j;
+            }
+    if (nloopi == NL && nloopj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+void serial2(int AR[][M], int NN, int NM, int NNL)
+{
+    int i, j;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            AR[i][j] = NNL + i + j;
+}
+
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/OWNCALC/owncal31.cdv

@@ -0,0 +1,611 @@
+/*      TESTING OF THE OWN CALCULASHION
+        FOR DISTRIBUTED ARRAY A[N][M].
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define N 32
+#define M 32
+#define K 32
+#define NL 1000
+
+static void owncal3101();
+static void owncal3102();
+static void owncal3103();
+static void owncal3104();
+static void owncal3105();
+static void owncal3106();
+static void owncal3107();
+static void owncal3108();
+static void owncal3109();
+static void owncal3110();
+
+static void serial3(int AR[][M][K], int NN, int NM, int NK, int NNL);
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+int main(int argc, char *argv[])
+{
+    printf("===START OF OWNCAL31========================\n");
+    owncal3101();
+    owncal3102();
+    owncal3103();
+    owncal3104();
+    owncal3105();
+    owncal3106();
+    owncal3107();
+    owncal3108();
+    owncal3109();
+    owncal3110();
+
+    printf("=== END OF OWNCAL31 ========================= \n");
+    return 0;
+}
+/* ---------------------------------------------OWNCAL3101  */
+void owncal3101()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3101";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region out(A)
+    {
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+/* ---------------------------------------------OWNCAL3102  */
+void owncal3102()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3102";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+    C[0][0][0] = N + M + K + NL + 2;
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    A[0][0][0] = N + M + K + NL + 2;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL3103  */
+void owncal3103()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3103";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+    int ni, nj, nii;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+
+    C[ni][nj][nii] = N + M + K + NL + 3;
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm actual(ni, nj, nii)
+
+    #pragma dvm region out(A), in(ni, nj, nii)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    A[ni][nj][nii] = N + M + K + NL + 3;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+/* ---------------------------------------------OWNCAL3104  */
+void owncal3104()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3104";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+    int ni, nj, nii;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+
+    C[ni + 1][nj + 1][nii + 1] = N + M + K + NL + 4;
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm actual(ni, nj, nii)
+
+    #pragma dvm region out(A), in(ni, nj, nii)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    A[ni + 1][nj + 1][nii + 1] = N + M + K + NL + 4;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+
+/* ---------------------------------------------OWNCAL3105  */
+void owncal3105()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3105";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+    int ni, nj, nii;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+
+    C[ni - 1][nj - 1][nii - 1] = -(N + M + K + NL + 5);
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm actual(ni, nj, nii)
+
+    #pragma dvm region out(A), in(ni, nj, nii)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    A[ni - 1][nj - 1][nii - 1] = -(N + M + K + NL + 5);
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL3106  */
+void owncal3106()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3106";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+    int ni, nj, nii;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+
+    C[ni + 1][nj - 1][nii + 1] = N + M + K + NL + 6;
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm actual(ni, nj, nii)
+
+    #pragma dvm region out(A), in(ni, nj, nii)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    A[ni + 1][nj - 1][nii + 1] = N + M + K + NL + 6;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+
+/* ---------------------------------------------OWNCAL3107  */
+void owncal3107()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3107";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+    int ni, nj, nii;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+
+    C[ni - 1][nj + 1][nii - 1] = N + M + K + NL + 7;
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm actual(ni, nj, nii)
+
+    #pragma dvm region out(A), in(ni, nj, nii)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    A[ni - 1][nj + 1][nii - 1] = N + M + K + NL + 7;
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL3108  */
+void owncal3108()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3108";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+
+    C[0][M - 1][K - 1] = N + M + K + NL + 8;
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    A[0][M - 1][K - 1] = N + M + K + NL + 8;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+
+/* ---------------------------------------------OWNCAL3109  */
+void owncal3109()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3109";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+
+    C[N - 1][M - 1][0] = N + M + K + NL + 9;
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    A[N - 1][M - 1][0] = N + M + K + NL + 9;
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+/* ---------------------------------------------OWNCAL3110  */
+void owncal3110()
+{
+    int C[N][M][K];
+    char tname[] = "OWN3110";
+    int i, j, ii, NN, NM, NK, NNL, nloopi, nloopj, nloopii;
+    int nj;
+
+    #pragma dvm array distribute[block][block][block]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+
+    serial3(C, NN, NM, NK, NNL);
+
+    nj = M / 2;
+    C[0][nj + 1][K - 1] = N + M + K + NL + 10;
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm actual(nj)
+    #pragma dvm region out(A), in(nj)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                A[i][j][ii] = NL + i + j + ii;
+
+    A[0][nj + 1][K - 1] = N + M + K + NL + 10;
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (A[i][j][ii] != C[i][j][ii]) {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+
+void serial3(int AR[][M][K], int NN, int NM, int NK, int NNL)
+{
+    int i,j,ii;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            for (ii = 0; ii < NK; ii++)
+                AR[i][j][ii] = NNL + i + j + ii;
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/OWNCALC/owncal41.cdv

@@ -0,0 +1,656 @@
+/*      TESTING OF THE OWN CALCULASHION
+        FOR DISTRIBUTED ARRAY A[N][M][K][L].
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define N 32
+#define M 32
+#define K 32
+#define L 32
+#define NL 1000
+
+static void owncal4101();
+static void owncal4102();
+static void owncal4103();
+static void owncal4104();
+static void owncal4105();
+static void owncal4106();
+static void owncal4107();
+static void owncal4108();
+static void owncal4109();
+static void owncal4110();
+
+static void serial4(int AR[][M][K][L], int NN, int NM, int NK, int NLL, int NNL);
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+int main(int argc, char *argv[])
+{
+    printf("===START OF OWNCAL41========================\n");
+    owncal4101();
+    owncal4102();
+    owncal4103();
+    owncal4104();
+    owncal4105();
+    owncal4106();
+    owncal4107();
+    owncal4108();
+    owncal4109();
+    owncal4110();
+
+    printf("=== END OF OWNCAL41 ========================= \n");
+    return 0;
+}
+/* ---------------------------------------------OWNCAL4101  */
+void owncal4101()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4101";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region out(A)
+    {
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+/* ---------------------------------------------OWNCAL4102  */
+void owncal4102()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4102";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+    C[0][0][0][0] = N + M + K + L + NL + 2;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    A[0][0][0][0] = N + M + K + L + NL + 2;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+/* ---------------------------------------------OWNCAL4103  */
+void owncal4103()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4103";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+    int ni, nj, nii, njj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+    njj = L / 2;
+
+    C[ni][nj][nii][njj] = N + M + K + L + NL + 3;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm actual(ni, nj, nii, njj)
+    #pragma dvm region out(A), in(ni, nj, nii, njj)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    A[ni][nj][nii][njj] = N + M + K + L + NL + 3;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+/* ---------------------------------------------OWNCAL4104  */
+void owncal4104()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4104";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+    int ni, nj, nii, njj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+    njj = L / 2;
+
+    C[ni + 1][nj + 1][nii + 1][njj + 1] = N + M + K + L + NL + 4;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm actual(ni, nj, nii, njj)
+    #pragma dvm region out(A), in(ni, nj, nii, njj)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    A[ni + 1][nj + 1][nii + 1][njj + 1] = N + M + K + L + NL + 4;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+
+/* ---------------------------------------------OWNCAL4105  */
+void owncal4105()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4105";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+    int ni, nj, nii, njj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+    njj = L / 2;
+
+    C[ni - 1][nj - 1][nii - 1][njj - 1] = -(N + M + K + L + NL + 5);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm actual(ni, nj, nii, njj)
+    #pragma dvm region out(A), in(ni, nj, nii, njj)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    A[ni - 1][nj - 1][nii - 1][njj - 1] = -(N + M + K + L + NL + 5);
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+/* ---------------------------------------------OWNCAL4106  */
+void owncal4106()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4106";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+    int ni, nj, nii, njj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+    njj = L / 2;
+
+    C[ni - 1][nj + 1][nii - 1][njj + 1] = N + M + K + L + NL + 6;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm actual(ni, nj, nii, njj)
+    #pragma dvm region out(A), in(ni, nj, nii, njj)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    A[ni - 1][nj + 1][nii - 1][njj + 1] = N + M + K + L + NL + 6;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL4107  */
+void owncal4107()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4107";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+    int ni, nj, nii, njj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+    ni = N / 2;
+    nj = M / 2;
+    nii = K / 2;
+    njj = L / 2;
+
+    C[ni + 1][nj - 1][nii + 1][njj - 1] = N + M + K + L + NL + 7;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm actual(ni, nj, nii, njj)
+    #pragma dvm region out(A), in(ni, nj, nii, njj)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    A[ni + 1][nj - 1][nii + 1][njj - 1] = N + M + K + L + NL + 7;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL4108  */
+void owncal4108()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4108";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+
+    C[0][M - 1][0][L - 1] = N + M + K + L + NL + 8;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    A[0][M - 1][0][L - 1] = N + M + K + L + NL + 8;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL4109  */
+void owncal4109()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4109";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+
+    C[N - 1][0][K - 1][0] = N + M + K + L + NL + 9;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    A[N][0][K - 1][0] = N + M + K + L + NL + 9;
+
+    } /*end region*/
+
+      #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------OWNCAL4110  */
+void owncal4110()
+{
+    int C[N][M][K][L];
+    char tname[] = "OWN4110";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    int nloopi, nloopj, nloopii, nloopjj;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A[N][M][K][L];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NLL = L;
+    NNL = NL;
+
+    serial4(C, NN, NM, NK, NLL, NNL);
+
+    C[0][0][K - 1][L - 1] = N + M + K + L + NL + 10;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    A[0][0][K - 1][L - 1] = N + M + K + L + NL + 10;
+
+    } /*end region*/
+
+    #pragma dvm get_actual(A)
+
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (A[i][j][ii][jj] != C[i][j][ii][jj]) {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+void serial4(int AR[][M][K][L], int NN, int NM, int NK, int NLL, int NNL)
+{
+    int i, j, ii, jj;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            for (ii = 0; ii < NK; ii++)
+                for (jj = 0; jj < NLL; jj++)
+                    AR[i][j][ii][jj] = NNL + i + j + ii + jj;
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/OWNCALC/settings

@@ -0,0 +1 @@
+DVM_ONLY=1

dvm/tools/tester/trunk/test-suite/Correctness/C/PARALLEL/parallel1.cdv

@@ -0,0 +1,340 @@
+/* PARALLEL1
+Testing PARALLEL directive */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void parallel11();
+static void parallel12();
+static void parallel13();
+static void parallel131();
+static void parallel14();
+static void parallel15();
+
+
+static void ansyes(const char tname[]);
+static void ansno (const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+
+static int erri, i, j, ia;
+
+int main(int an, char **as)
+{
+    printf("=== START OF PARALLEL1 ===================\n");
+
+    /* arrA1[BLOCK] PARALLEL ON arrA[i+4] normal */
+    parallel11();
+    /* arrA1[BLOCK] PARALLEL ON arrA[-i+8] reverse */
+//  parallel12();
+    /* arrA1[BLOCK] PARALLEL ON arrA[2*i+8] stretch */
+    parallel13();
+    /* arrA1[BLOCK] PARALLEL ON arrA[2*i+1] small array */
+    parallel131();
+    /* arrA1[BLOCK] PARALLEL ON arrA[] */
+    parallel14();
+    /* arrA1[BLOCK] PARALLEL ON arrA[2] */
+    parallel15();
+
+    printf ("=== END OF PARALLEL1 ===================\n");
+    return 0;
+}
+/* ---------------------------------------------parallel11 */
+    /* arrA1[BLOCK]  PARALLEL ON arrA[i+4] normal */
+void parallel11()
+{
+    #define AN1 8
+
+/*  parameters for PARALLEL arrA1[k1i * i + li] */
+    int k1i = 1;
+    int li = 4;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    char tname[] = "paral11 ";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region local(A1)
+    {
+    #pragma dvm parallel([i] on A1[i])
+    for (i = 0; i < AN1; i++)
+        A1[i] = i;
+
+    #pragma dvm parallel([i] on A1[k1i * i + li]) private(ia), reduction(min(erri))
+    for (i = 0; i < ((AN1-li)/k1i); i++)
+    {
+        ia = k1i * i + li;
+        if (A1[ia] != ia)
+              erri = Min(erri, i);
+    }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+}
+
+/* ---------------------------------------------parallel12 */
+    /* arrA1[BLOCK]  PARALLEL ON arrA[-i+8]  reverse */
+void parallel12()
+{
+    #define AN1 7
+
+/*  parameters for PARALLEL arrA1[k1i * i + li] */
+    int k1i = -1;
+    int li = 8;
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    char tname[] = "paral12 ";
+
+    A1 = (int*)malloc(AN1*sizeof(int));
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A1[i])
+    for (i = 0; i < AN1; i++)
+        A1[i] = i * 2;
+
+    #pragma dvm parallel([i] on A1[k1i * i + li]) private(ia), reduction(min(erri))
+    for (i = 0; i < ((AN1-li)/k1i); i++)
+    {
+        ia = k1i * i + li;
+        if (A1[ia] != (ia*2))
+              erri = Min(erri, i);
+    }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free (A1);
+
+    #undef AN1
+}
+
+/* ---------------------------------------------parallel13 */
+    /* arrA1[BLOCK]  PARALLEL ON arrA[2*i+8] stretch */
+void parallel13()
+{
+    #define AN1 20
+
+/*  parameters for PARALLEL arrA1[k1i * i + li]*/
+    int k1i = 2;
+    int li = 8;
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    char tname[] = "paral13 ";
+
+    A1 = (int*)malloc(sizeof(int[AN1]));
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A1[i])
+    for (i = 0; i < AN1; i++)
+        A1[i] = i + 5;
+
+    #pragma dvm parallel([i] on A1[k1i * i + li]) private(ia), reduction(min(erri))
+    for (i = 0; i < ((AN1-li)/k1i); i++)
+    {
+        ia = k1i * i + li;
+        if (A1[ia] != (ia + 5))
+              erri = Min(erri, i);
+    }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(A1);
+    #undef AN1
+}
+
+/* ---------------------------------------------parallel131 */
+    /* arrA1[BLOCK]  PARALLEL ON arrA[2*i+1] small array */
+void parallel131()
+{
+    #define AN1 5
+
+/*  parameters for PARALLEL arrA1[k1i * i + li] */
+    int k1i = 2;
+    int li = 1;
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    char tname[] = "paral131";
+
+    A1 = (int*)malloc(AN1*sizeof(int));
+
+    erri = ER;
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A1[i])
+    for (i = 0; i < AN1; i++)
+        A1[i] = i;
+    } /* end region */
+
+    #pragma dvm actual(erri)
+
+    #pragma dvm region local(A1)
+    {
+    #pragma dvm parallel([i] on A1[k1i * i + li]) private(ia), reduction(min(erri))
+    for (i = 0; i < ((AN1-li)/k1i); i++)
+    {
+        ia=k1i * i + li;
+        if (A1[ia] != ia)
+              erri = Min(erri, i);
+    }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free (A1);
+
+    #undef AN1
+}
+
+/* ---------------------------------------------parallel14 */
+    /* arrA1[BLOCK]  PARALLEL ON arrA[] */
+void parallel14()
+{
+    #define AN1 20
+    #define BN1 10
+
+/*  parameters for PARALLEL arrA1[*] */
+    #define k1i 0
+    #define li 0
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array distribute[*]
+    int *B1;
+
+    char tname[] = "paral14 ";
+
+    A1 = (int*)malloc(AN1*sizeof(int));
+    B1 = (int*)malloc(BN1*sizeof(int));
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region local(A1, B1)
+    {
+    #pragma dvm parallel([i] on A1[i])
+    for (i = 0; i < AN1; i++)
+        A1[i] = i;
+
+    for (i = 0; i < BN1; i++)
+        B1[i] = i;
+
+    #pragma dvm parallel([i] on A1[]) reduction(min(erri))
+    for (i = 0; i < BN1; i++)
+        if (B1[i] != i)
+              erri = Min(erri, i);
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free (A1);
+    free (B1);
+
+    #undef AN1
+    #undef BN1
+    #undef k1i
+    #undef li
+}
+
+/* ---------------------------------------------parallel15 */
+/* arrA1[BLOCK] PARALLEL ON arrA[2] */
+void parallel15()
+{
+    #define AN1 15
+
+/*  parameters for PARALLEL arrA1[li] */
+    #define k1i 0
+    #define li 2
+
+    #pragma dvm array distribute[block]
+    int *A1;
+
+    char tname[] = "paral15 ";
+
+    A1 = (int(*))malloc(AN1*sizeof(int));
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region local(A1)
+    {
+    #pragma dvm parallel([i] on A1[i])
+    for(i = 0; i < AN1; i++)
+        A1[i] = i;
+
+    #pragma dvm parallel ([i] on  A1[li]) reduction(min(erri)), private(ia)
+    for(i = 0; i < AN1; i++) {
+        ia = li;
+        if (A1[ia] != ia)
+           erri = Min(erri, i);
+    }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(A1);
+    #undef AN1
+    #undef k1i
+    #undef li
+}
+
+/*-------------------------------------------------------*/
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/PARALLEL/parallel2.cdv

@@ -0,0 +1,253 @@
+/*    PARALLEL2
+Testing PARALLEL directive */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void parallel21();
+static void parallel22();
+static void parallel23();
+static void parallel24();
+
+static void ansyes(const char tname[]);
+static void ansno (const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+
+static int erri,i,j,ia,ja;
+
+int main(int an, char **as)
+{
+    printf("=== START OF PARALLEL2 ===================\n");
+
+    /* PARALLEL ON arrA[i][2*j]  stretching along j */
+    parallel21();
+    /* PARALLEL ON arrA[i+4][j]  shift along i */
+    parallel22();
+    /* PARALLEL ON arrA[-i+8][j] reverse on i */
+//  parallel23();
+    /* PARALLEL ON arrA[i+4][j+4]  shift along i and j */
+    parallel24();
+
+    printf ("=== END OF PARALLEL2 ===================\n");
+
+    return 0;
+}
+
+/* ---------------------------------------------parallel21 */
+    /* PARALLEL ON arrA[i][2*j]  stretching along j */
+void parallel21()
+{
+    #define AN1 8
+    #define AN2 8
+
+/*  parameters for PARALLEL arrA2[k1i * i + li][k2j * j + lj] */
+    int k1i = 1, li = 0;
+    int k2j = 2, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+
+    char tname[] = "paral21";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region local(A2)
+    {
+    #pragma dvm parallel([i][j] on A2[i][j])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            A2[i][j] = i*NL+j;
+
+    #pragma dvm parallel([i][j] on A2[k1i*i+li][k2j*j+lj]) private(ia, ja), reduction(min(erri))
+    for (i = 0; i < (AN1-li)/k1i; i++)
+        for (j = 0; j < (AN2-lj)/k2j ; j++)
+        {
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                erri = Min(erri, ia * NL + ja);
+        }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------parallel22 */
+    /* PARALLEL ON arrA[i+4][j]  shift along i */
+void parallel22()
+{
+    #define AN1 16
+    #define AN2 10
+
+/*  parameters for PARALLEL arrA2[k1i * i + li][k2j * j + lj] */
+    int k1i = 1, li = 4;
+    int k2j = 1, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int (*A2)[AN2];
+
+    char tname[] = "paral22";
+
+    A2 = (int(*)[AN2])malloc(AN1*sizeof(int[AN2]));
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A2[i][j])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            A2[i][j] = i * NL + j + 2;
+
+    #pragma dvm parallel([i][j] on A2[k1i*i+li][k2j*j+lj]) private(ia, ja), reduction(min(erri))
+    for (i = 0; i < (AN1-li) / k1i; i++)
+        for (j = 0; j < (AN2-lj) / k2j; j++)
+        {
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja) + 2)
+                erri = Min(erri, ia * NL + ja);
+        }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free (A2);
+
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------parallel23  */
+    /* PARALLEL ON arrA[-i+8][j] reverse on i*/
+void parallel23()
+{
+    #define AN1 8
+    #define AN2 14
+
+/*  parameters for PARALLEL arrA2[k1i * i + li][k2j * j + lj] */
+    int k1i = -1, li = 8;
+    int k2j =  1, lj = 0;
+
+    #pragma dvm array distribute[block][block]
+    int (*A2)[AN2];
+
+    char tname[] = "paral23";
+
+    A2 = (int(*)[AN2])malloc(AN1*AN2*sizeof(int));
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region local(A2)
+    {
+    #pragma dvm parallel([i][j] on A2[i][j])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            A2[i][j] = i * NL + j - 3;
+
+    #pragma dvm parallel([i][j] on A2[k1i*i+li][k2j*j+lj]) private(ia, ja), reduction(min(erri))
+    for (i = 0; i < (AN1 - li) / k1i; i++)
+        for (j = 0; j < (AN2 - lj) / k2j; j++)
+        {
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja) - 3)
+                erri = Min(erri, ia * NL + ja);
+        }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(A2);
+    #undef AN1
+    #undef AN2
+}
+
+/* ---------------------------------------------parallel24 */
+    /* PARALLEL ON arrA[i+4][j+4]  shift along i and j */
+void parallel24()
+{
+    #define AN1 16
+    #define AN2 15
+
+/*  parameters for PARALLEL arrA2[k1i * i + li][k2j * j + lj] */
+    int k1i = 1, li = 4;
+    int k2j = 1, lj = 4;
+
+    #pragma dvm array distribute[block][block]
+    int (*A2)[AN2];
+
+    char tname[] = "paral24";
+
+    A2 = malloc(sizeof(int[AN1][AN2]));
+
+    erri= ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region local(A2)
+    {
+    #pragma dvm parallel([i][j] on A2[i][j])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            A2[i][j] = i * NL + j;
+
+    #pragma dvm parallel([i][j] on A2[k1i*i+li][k2j*j+lj]) private(ia, ja), reduction(min(erri))
+    for (i = 0; i < (AN1 - li) / k1i; i++)
+        for (j = 0; j < (AN2 - lj) / k2j ; j++)
+        {
+            ia = k1i * i + li;
+            ja = k2j * j + lj;
+            if (A2[ia][ja] != (ia * NL + ja))
+                erri = Min(erri, ia * NL + ja);
+         }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free (A2);
+
+    #undef AN1
+    #undef AN2
+}
+
+/*-------------------------------------------------------*/
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/PARALLEL/parallel3.cdv

@@ -0,0 +1,518 @@
+/*    PARALLEL3
+Testing PARALLEL directive */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void parallel31();
+static void parallel32();
+static void parallel33();
+static void parallel34();
+static void parallel341();
+static void parallel35();
+static void parallel36();
+
+static void ansyes(const char tname[]);
+static void ansno (const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+
+static int erri,i,j,n,l,ia,ja,na,ib,jb,nb;
+
+int main(int an, char **as)
+{
+    printf("=== START OF PARALLEL3 ===================\n");
+    /* PARALLEL ON  arrA[i][2* j][n] stretching */
+    parallel31();
+    /* PARALLEL ON  arrA[i+2][ j][n] shift */
+    parallel32();
+    /* PARALLEL ON  arrA[i][ j][-n+8] reverse */
+//  parallel33();
+    /* PARALLEL ON  arrA[i][ j][2]  compression */
+    parallel34();
+    /* PARALLEL ON  arrA[2*i][3*j][1] stretching and compression */
+    parallel341 ();
+    /* PARALLEL ON  arrA[][j][n]  replication */
+    parallel35();
+    /* PARALLEL ON arrA[1][2*j+1][3] */
+    parallel36();
+
+    printf ("=== END OF PARALLEL3 ===================\n");
+
+    return 0;
+}
+
+/* ---------------------------------------------parallel31 */
+    /* PARALLEL ON arrA[i][2*j][k] stretching */
+void parallel31()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 4
+
+/*  parameters for PARALLEL ON arrA[k1i*i+li][k2j*j+lj][k3n*n+ln] */
+    int k1i = 1, li = 0;
+    int k2j = 2, lj = 0;
+    int k3n = 1, ln = 0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+
+    char tname[] = "paral31 ";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region local(A3)
+    {
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+
+    #pragma dvm parallel([i][j][n] on A3[k1i*i+li][k2j*j+lj][k3n*n+ln]) private(ia,ja,na), reduction(min(erri))
+    for (i = 0; i < ((AN1 - li) / k1i); i++)
+        for (j = 0; j < ((AN2 - lj) / k2j); j++)
+            for (n = 0; n < ((AN3 - ln) / k3n); n++)
+            {
+                ia = k1i * i + li;
+                ja = k2j * j + lj;
+                na = k3n * n + ln;
+                if (A3[ia][ja][na] != (ia * NL / 10 + ja * NL / 100 + na * NL / 1000))
+                    erri = Min(erri, ia * NL / 10 + ja * NL / 100 + na * NL / 1000);
+            }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+
+/* ---------------------------------------------parallel32 */
+    /* PARALLEL ON arrA[i+2][j][k] shift */
+void parallel32()
+{
+    #define AN1 5
+    #define AN2 5
+    #define AN3 5
+
+/* parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln] */
+    int k1i = 1, li = 2;
+    int k2j = 1, lj = 0;
+    int k3n = 1, ln = 0;
+
+    #pragma dvm array distribute[block][block][block]
+    int (*A3)[AN2][AN3];
+
+    char tname[] = "paral32 ";
+
+    A3 = (int(*)[AN2][AN3])malloc(AN1*sizeof(int[AN2][AN3]));
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++) {
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + 2;
+            }
+
+    #pragma dvm parallel([i][j][n] on A3[k1i*i+li][k2j*j+lj][k3n*n+ln]) private(ia,ja,na), reduction(min(erri))
+    for (i = 0; i < ((AN1 - li) / k1i); i++)
+        for (j = 0; j < ((AN2 - lj) / k2j); j++)
+            for (n = 0; n < ((AN3 - ln) / k3n); n++)
+            {
+                ia = k1i * i + li;
+                ja = k2j * j + lj;
+                na = k3n * n + ln;
+                if (A3[ia][ja][na] != (ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + 2))
+                    erri = Min(erri, ia * NL / 10 + ja * NL / 100 + na * NL / 1000);
+            }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free (A3);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+/* ---------------------------------------------parallel33 */
+    /* PARALLEL ON  arrA[i][j][-k+8] reverse */
+void parallel33()
+{
+    #define AN1 5
+    #define AN2 5
+    #define AN3 9
+
+/* parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln] */
+    int k1i =  1, li = 0;
+    int k2j =  1, lj = 0;
+    int k3n = -1, ln = 8;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+
+    char tname[] = "paral33 ";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region inout(A3)
+    {
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL /1000;
+
+    #pragma dvm parallel([i][j][n] on A3[k1i*i+li][k2j*j+lj][k3n*n+ln]) private(ia,ja,na), reduction(min(erri))
+    for (i = 0; i < ((AN1 - li) / k1i); i++)
+        for (j = 0; j < ((AN2 - lj - 1) / k2j); j++)
+            for (n = 0; n < ((AN3 - ln - 1) / k3n); n++)
+            {
+                ia = k1i * i + li;
+                ja = k2j * j + lj;
+                na = k3n * n + ln;
+                if (A3[ia][ja][na] != (ia * NL / 10 + ja * NL / 100 + na * NL/1000))
+                    erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000);
+            }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+}
+/* ---------------------------------------------parallel34 */
+    /* PARALLEL ON  arrA[i][ j][2] compression */
+void parallel34()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define BN1 3
+    #define BN2 3
+    #define BN3 3
+
+/*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][ln] */
+    #define k1i 1
+    #define li 0
+    #define k2j 1
+    #define lj 0
+    #define k3n 0
+    #define ln 2
+
+    #pragma dvm array distribute[block][block][block]
+    int (*A3)[AN2][AN3];
+    #pragma dvm array     /* deferred aligning */
+    int (*B3)[BN2][BN3];
+
+    char tname[] = "paral34 ";
+
+    A3 = (int(*)[AN2][AN3])malloc(AN1*sizeof(int[AN2][AN3]));
+    B3 = (int(*)[BN2][BN3])malloc(BN1*sizeof(int[BN2][BN3]));
+
+    #pragma dvm realign(B3[i][j][] with A3[k1i*i+li][k2j*j+lj][ln])
+
+    erri = ER;
+
+    #pragma dvm region inout(A3, B3)
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for(i = 0; i < BN1; i++)
+        for(j = 0; j < BN2; j++)
+            for(n = 0; n < BN3; n++) {
+                B3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+            }
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for(i = 0; i < AN1; i++)
+        for(j = 0; j < AN2; j++)
+            for(n = 0; n < AN3; n++) {
+                 A3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+             }
+    } /*end region*/
+
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel ([i][j][n] on  A3[k1i * i + li][k2j * j + lj][ln]) reduction(min(erri))
+     for(i = 0; i < BN1; i++)
+        for(j = 0; j < BN2; j++)
+            for(n = 0; n < BN3; n++) {
+                if (B3[i][j][n] != i * NL / 10 + j * NL / 100 + n * NL / 1000)
+                    erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000);
+             }
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+         ansyes(tname);
+    else
+        ansno(tname);
+
+    free (B3);
+    free (A3);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef k1i
+    #undef li
+    #undef k2j
+    #undef lj
+    #undef k3n
+    #undef ln
+}
+/* ---------------------------------------------parallel341 */
+    /* PARALLEL ON arrA[2*i][3*j][1]  stretching and compression */
+void parallel341()
+{
+    #define AN1 8
+    #define AN2 10
+    #define AN3 6
+    #define BN1 3
+    #define BN2 3
+    #define BN3 3
+
+/* parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][ln] */
+    int k1i = 2, li = 0;
+    int k2j = 3, lj = 0;
+    int k3n = 0, ln = 1;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+
+    #pragma dvm array align([i][j][] with A3[k1i*i+li][k2j*j+lj][ln])
+    int B3[BN1][BN2][BN3];
+
+    char tname[] = "paral341";
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region local(A3, B3)
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + 4;
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+
+    #pragma dvm parallel([i][j][n] on A3[k1i*i+li][k2j*j+lj][ln]) reduction(min(erri))
+    for (i = 0; i <BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                if (B3[i][j][n] != (i * NL / 10 + j * NL / 100 + n * NL / 1000 + 4))
+                    erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000);
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+
+/* ---------------------------------------------parallel35 */
+               /* PARALLEL ON arrA[][j][k] */
+void parallel35()
+{
+    #define AN1 10
+    #define AN2 12
+    #define AN3 16
+    #define BN1 6
+    #define BN2 5
+    #define BN3 4
+
+/* parameters for PARALLEL ON arrA[*][k2j*j+lj][k3n*n+ln] */
+    int k1i = 0, li = 0;
+    int k2j = 1, lj = 0;
+    int k3n = 1, ln = 0;
+
+    #pragma dvm array distribute[block][block][block]
+    int (*A3)[AN2][AN3];
+    #pragma dvm array   /* deferred aligning */
+    int (*B3)[BN2][BN3];
+
+    char tname[] = "paral35 ";
+
+    A3 = (int(*)[AN2][AN3])malloc(AN1*sizeof(int[AN2][AN3]));
+    B3 = (int(*)[BN2][BN3])malloc(BN1*sizeof(int[BN2][BN3]));
+
+    #pragma dvm realign(B3[][j][n] with A3[][k2j*j+lj][k3n*n+ln])
+
+    erri = ER;
+
+    #pragma dvm region in(A3, B3), out(A3, B3)
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + 5;
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + 7;
+    } /* end region */
+
+    #pragma dvm actual(erri)
+
+    for (i = 0; i < BN1; i++)
+    {
+        #pragma dvm region
+        {
+        #pragma dvm parallel([j][n] on A3[][k2j*j+lj][k3n*n+ln]) reduction(min(erri))
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                if (B3[i][j][n] != (i * NL / 10 + j * NL / 100 + n * NL / 1000 + 5))
+                    erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000);
+        } /* end region */
+    }
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free (B3);
+    free (A3);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+/* ---------------------------------------------parallel36 */
+               /* PARALLEL ON arrA[1][2*j+1][3] */
+void parallel36()
+{
+    #define AN1 6
+    #define AN2 8
+    #define AN3 7
+    #define BN1 4
+    #define BN2 3
+    #define BN3 5
+
+/* parameters for PARALLEL ON arrA[li][k2j*j+lj][ln] */
+    int k1i = 0, li = 1;
+    int k2j = 2, lj = 1;
+    int k3n = 0, ln = 3;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+
+    #pragma dvm array   /* deferred  aligning */
+    int (*B3)[BN2][BN3];
+
+    char tname[] = "paral36 ";
+
+    B3 = (int(*)[BN2][BN3])malloc(BN1*sizeof(int[BN2][BN3]));
+    #pragma dvm realign(B3[i][j][n] with A3[li][k2j*j+lj][ln])
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region inout(A3), inout(B3)
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                A3[i][j][n] = i * NL / 10 + j * NL / 100 + n * NL / 1000;
+
+    #pragma dvm parallel([i][j][n] on A3[li][k2j*j+lj][ln]) reduction(min(erri))
+    for (i = 0; i <BN1; i++)
+       for (j = 0; j < BN2; j++)
+          for (n = 0; n < BN3; n++)
+                if (B3[i][j][n] != (i * NL / 10 + j * NL / 100 + n * NL / 1000))
+                    erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL /1000);
+    } /* end region */
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free (B3);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+
+/*-------------------------------------------------------*/
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/PARALLEL/parallel4.cdv

@@ -0,0 +1,671 @@
+/* PARALLEL4
+
+TESTING parallel CLAUSE */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) (((a) < (b)) ? (a) : (b))
+
+static void parallel41();
+static void parallel42();
+static void parallel43();
+static void parallel44();
+static void parallel45();
+static void parallel46();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+static int PN = 2;
+static int erri, NNL, i, j, n, m, ia, ja, na, ma, ib, jb, nb, mb, Avalue, Bvalue, s, cs;
+
+int main(int an, char **as)
+{
+    printf("===START OF parallel4========================\n");
+/* PARALLEL ON  arrA[i][2* j][k][3*l] stretching */
+    parallel41();
+/* PARALLEL ON  arrA[i+2][ j][k][ l+3] */
+    parallel42();
+/* PARALLEL ON  arrA[i][ j][-k+8][- l+8]  reverse */
+//    parallel43();
+/* PARALLEL ON  arrA[i][ j][2][ l]
+                                              compression             !! */
+    parallel44();
+/* PARALLEL ON  arrA[i][ j][ ][ k]
+                                                replication */
+    parallel45();
+/* PARALLEL ON  arrA[i][ j][ ][3]
+                                               compression and replication */
+    parallel46();
+
+    printf("=== END OF parallel4 =========================\n");
+    return 0;
+}
+/* ---------------------------------------------parallel41 */
+/* arrA4[BLOCK][BLOCK] [BLOCK] [BLOCK]
+        PARALLEL ON  arrA[i][2* j][k][3*l] stretching */
+void parallel41()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 2
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 1
+    #define k4n 0
+    #define ln 0
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 3
+    #define lm 0
+
+    #pragma dvm array distribute[block][block][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+
+    char tname[] = "paral41 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(A4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][k3n * n + ln][k4m * m + lm]) reduction(min(erri)), private(ia, ja, na, ma)
+    for (i = 0; i < ((AN1 - li) / k1i); i++)
+        for (j = 0; j < ((AN2 - lj) / k2j); j++)
+            for (n = 0; n < ((AN3 - ln) / k3n); n++)
+                for (m = 0; m < ((AN4 - lm) / k4m); m++) {
+                    ia = k1i * i + li;
+                    ja = k2j * j + lj;
+                    na = k3n * n + ln;
+                    ma = k4m * m + lm;
+                    if (A4[ia][ja][na][ma] != ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+                }
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel42 */
+/* PARALLEL ON  arrA[i+2][ j][k][ l+3]  shift */
+void parallel42()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 2
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 1
+    #define k4n 0
+    #define ln 0
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 1
+    #define lm 3
+
+    #pragma dvm array distribute[block][block][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+
+    char tname[] = "paral42 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(A4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][k3n * n + ln][k4m * m + lm]) reduction(min(erri)), private(ia, ja, na, ma)
+    for (i = 0; i < ((AN1 - li) / k1i); i++)
+        for (j = 0; j < ((AN2 - lj) / k2j); j++)
+            for (n = 0; n < ((AN3 - ln) / k3n); n++)
+                for (m = 0; m < ((AN4 - lm) / k4m); m++) {
+                    ia = k1i * i + li;
+                    ja = k2j * j + lj;
+                    na = k3n * n + ln;
+                    ma = k4m * m + lm;
+                    if (A4[ia][ja][na][ma] != ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+                }
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel43 */
+/* PARALLEL ON  arrA[i][ j][-k+8][- l+8]  reverse */
+void parallel43()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n -1
+    #define k4n 0
+    #define ln 8
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m -1
+    #define lm 8
+
+    #pragma dvm array distribute[block][block][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+
+    char tname[] = "paral43 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(A4)
+    //#pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][k3n * n + ln][k4m * m + lm]) reduction(min(erri)), private(ia, ja, na, ma)
+    for (i = 0; i < ((AN1 - li) / k1i); i++)
+        for (j = 0; j < ((AN2 - lj) / k2j); j++)
+            for (n = 0; n < ((AN3 - ln) / k3n); n++)
+                for (m = 0; m < ((AN4 - lm) / k4m); m++) {
+                    ia = k1i * i + li;
+                    ja = k2j * j + lj;
+                    na = k3n * n + ln;
+                    ma = k4m * m + lm;
+                    if (A4[ia][ja][na][ma] != ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+                }
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel44 */
+/* PARALLEL ON  arrA[i][ j][2][ l] */
+void parallel44()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    #define BN1 3
+    #define BN2 3
+    #define BN3 3
+    #define BN4 3
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 0
+    #define k4n 0
+    #define ln 2
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 1
+    #define lm 0
+
+    #pragma dvm array distribute[block][block][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+    #pragma dvm array
+    int (*B4)[BN2][BN3][BN4];
+    B4 = (int (*)[BN2][BN3][BN4])malloc(BN1*sizeof(int[BN2][BN3][BN4]));
+    #pragma dvm realign(B4[i][j][n][m] with A4[k1i*i+li][k2j*j+lj][ln][k4m*m+lm])
+
+
+    char tname[] = "paral44 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(B4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][ln][k4m * m + lm]) reduction(min(erri))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    if (B4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B4);
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel45 */
+/* PARALLEL ON  arrA[i][ j][ ][ k] */
+void parallel45()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    #define BN1 3
+    #define BN2 3
+    #define BN3 3
+    #define BN4 3
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 0
+    #define k4n 0
+    #define ln 0
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 1
+    #define lm 0
+
+    #pragma dvm array distribute[block][block][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+    #pragma dvm array
+    int (*B4)[BN2][BN3][BN4];
+    B4 = (int (*)[BN2][BN3][BN4])malloc(BN1*sizeof(int[BN2][BN3][BN4]));
+    #pragma dvm realign(B4[i][j][n][m] with A4[k1i*i+li][k2j*j+lj][][k4m*m+lm])
+
+    char tname[] = "paral45 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(B4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][][k4m * m + lm]) reduction(min(erri))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    if (B4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B4);
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel46 */
+/* PARALLEL ON  arrA[i][ j][ ][3] */
+void parallel46()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    #define BN1 3
+    #define BN2 3
+    #define BN3 3
+    #define BN4 3
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 0
+    #define k4n 0
+    #define ln 0
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 0
+    #define lm 3
+
+    #pragma dvm array distribute[block][block][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+    #pragma dvm array
+    int (*B4)[BN2][BN3][BN4];
+    B4 = (int (*)[BN2][BN3][BN4])malloc(BN1*sizeof(int[BN2][BN3][BN4]));
+    #pragma dvm realign(B4[i][j][n][m] with A4[k1i*i+li][k2j*j+lj][][lm])
+
+    char tname[] = "paral46 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(B4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][][lm]) reduction(min(erri))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    if (B4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B4);
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/*-------------------------------------------------------*/
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/PARALLEL/paralplus34.cdv

@@ -0,0 +1,672 @@
+/* PARALLELPLUS34
+
+TESTING parallel CLAUSE
+arrA4[BLOCK][*][ BLOCK][BLOCK] or arrA4[*][BLOCK][ BLOCK][BLOCK]  etc. */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) (((a) < (b)) ? (a) : (b))
+
+static void parallel41();
+static void parallel42();
+static void parallel43();
+static void parallel44();
+static void parallel45();
+static void parallel46();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+static int PN = 2;
+static int erri, NNL, i, j, n, m, ia, ja, na, ma, ib, jb, nb, mb, Avalue, Bvalue, s, cs;
+
+int main(int an, char **as)
+{
+    printf("===START OF paralplus34========================\n");
+/* PARALLEL ON  arrA[i][2* j][k][3*l] stretching */
+    parallel41();
+/* PARALLEL ON  arrA[i+2][ j][k][ l+3] */
+    parallel42();
+/* PARALLEL ON  arrA[i][ j][-k+8][- l+8]  reverse */
+//    parallel43();
+/* PARALLEL ON  arrA[i][ j][2][ l]
+                                              compression             !! */
+    parallel44();
+/* PARALLEL ON  arrA[i][ j][ ][ k]
+                                                replication */
+    parallel45();
+/* PARALLEL ON  arrA[i][ j][ ][3]
+                                               compression and replication */
+    parallel46();
+
+    printf("=== END OF paralplus34 =========================\n");
+    return 0;
+}
+/* ---------------------------------------------parallel41 */
+/* arrA4[BLOCK][*] [BLOCK] [BLOCK]
+        PARALLEL ON  arrA[i][2* j][k][3*l] stretching */
+void parallel41()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 2
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 1
+    #define k4n 0
+    #define ln 0
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 3
+    #define lm 0
+
+    #pragma dvm array distribute[block][*][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+
+    char tname[] = "paral+41 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(A4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][k3n * n + ln][k4m * m + lm]) reduction(min(erri)), private(ia, ja, na, ma)
+    for (i = 0; i < ((AN1 - li) / k1i); i++)
+        for (j = 0; j < ((AN2 - lj) / k2j); j++)
+            for (n = 0; n < ((AN3 - ln) / k3n); n++)
+                for (m = 0; m < ((AN4 - lm) / k4m); m++) {
+                    ia = k1i * i + li;
+                    ja = k2j * j + lj;
+                    na = k3n * n + ln;
+                    ma = k4m * m + lm;
+                    if (A4[ia][ja][na][ma] != ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+                }
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel42 */
+/* PARALLEL ON  arrA[i+2][ j][k][ l+3]  shift */
+void parallel42()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 2
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 1
+    #define k4n 0
+    #define ln 0
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 1
+    #define lm 3
+
+    #pragma dvm array distribute[*][block][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+
+    char tname[] = "paral+42 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(A4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][k3n * n + ln][k4m * m + lm]) reduction(min(erri)), private(ia, ja, na, ma)
+    for (i = 0; i < ((AN1 - li) / k1i); i++)
+        for (j = 0; j < ((AN2 - lj) / k2j); j++)
+            for (n = 0; n < ((AN3 - ln) / k3n); n++)
+                for (m = 0; m < ((AN4 - lm) / k4m); m++) {
+                    ia = k1i * i + li;
+                    ja = k2j * j + lj;
+                    na = k3n * n + ln;
+                    ma = k4m * m + lm;
+                    if (A4[ia][ja][na][ma] != ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+                }
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel43 */
+/* PARALLEL ON  arrA[i][ j][-k+8][- l+8]  reverse */
+void parallel43()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n -1
+    #define k4n 0
+    #define ln 8
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m -1
+    #define lm 8
+
+    #pragma dvm array distribute[block][block][*][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+
+    char tname[] = "paral+43 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(A4)
+    //#pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][k3n * n + ln][k4m * m + lm]) reduction(min(erri)), private(ia, ja, na, ma)
+    for (i = 0; i < ((AN1 - li) / k1i); i++)
+        for (j = 0; j < ((AN2 - lj) / k2j); j++)
+            for (n = 0; n < ((AN3 - ln) / k3n); n++)
+                for (m = 0; m < ((AN4 - lm) / k4m); m++) {
+                    ia = k1i * i + li;
+                    ja = k2j * j + lj;
+                    na = k3n * n + ln;
+                    ma = k4m * m + lm;
+                    if (A4[ia][ja][na][ma] != ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+                }
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel44 */
+/* PARALLEL ON  arrA[i][ j][2][ l] */
+void parallel44()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    #define BN1 3
+    #define BN2 3
+    #define BN3 3
+    #define BN4 3
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 0
+    #define k4n 0
+    #define ln 2
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 1
+    #define lm 0
+
+    #pragma dvm array distribute[block][block][*][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+    #pragma dvm array
+    int (*B4)[BN2][BN3][BN4];
+    B4 = (int (*)[BN2][BN3][BN4])malloc(BN1 * sizeof(int[BN2][BN3][BN4]));
+    #pragma dvm realign(B4[i][j][n][m] with A4[k1i*i+li][k2j*j+lj][ln][k4m*m+lm])
+
+
+    char tname[] = "paral+44 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(B4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][ln][k4m * m + lm]) reduction(min(erri))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    if (B4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B4);
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel45 */
+/* PARALLEL ON  arrA[i][ j][ ][ k] */
+void parallel45()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    #define BN1 3
+    #define BN2 3
+    #define BN3 3
+    #define BN4 3
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 0
+    #define k4n 0
+    #define ln 0
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 1
+    #define lm 0
+
+    #pragma dvm array distribute[block][block][block][*]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+    #pragma dvm array
+    int (*B4)[BN2][BN3][BN4];
+    B4 = (int (*)[BN2][BN3][BN4])malloc(BN1 * sizeof(int[BN2][BN3][BN4]));
+    #pragma dvm realign(B4[i][j][n][m] with A4[k1i*i+li][k2j*j+lj][][k4m*m+lm])
+
+    char tname[] = "paral+45 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(B4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][][k4m * m + lm]) reduction(min(erri))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    if (B4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B4);
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/* ---------------------------------------------parallel46 */
+/* PARALLEL ON  arrA[i][ j][ ][3] */
+void parallel46()
+{
+    #define AN1 6
+    #define AN2 6
+    #define AN3 6
+    #define AN4 6
+    #define BN1 3
+    #define BN2 3
+    #define BN3 3
+    #define BN4 3
+    /*  parameters for PARALLEL ON  arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    #define k1i 1
+    #define k2i 0
+    #define k3i 0
+    #define k4i 0
+    #define li 0
+    #define k1j 0
+    #define k2j 1
+    #define k3j 0
+    #define k4j 0
+    #define lj 0
+    #define k1n 0
+    #define k2n 0
+    #define k3n 0
+    #define k4n 0
+    #define ln 0
+    #define k1m 0
+    #define k2m 0
+    #define k3m 0
+    #define k4m 0
+    #define lm 3
+
+    #pragma dvm array distribute[*][block][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    A4 = (int (*)[AN2][AN3][AN4])malloc(AN1 * sizeof(int[AN2][AN3][AN4]));
+    #pragma dvm array
+    int (*B4)[BN2][BN3][BN4];
+    B4 = (int (*)[BN2][BN3][BN4])malloc(BN1 * sizeof(int[BN2][BN3][BN4]));
+    #pragma dvm realign(B4[i][j][n][m] with A4[k1i*i+li][k2j*j+lj][][lm])
+
+    char tname[] = "paral+46 ";
+    erri = ER;
+    NNL = NL;
+    #pragma dvm actual(erri)
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+    } /*end region*/
+    #pragma dvm get_actual(B4)
+    #pragma dvm parallel([i][j][n][m] on  A4[k1i * i + li][k2j * j + lj][][lm]) reduction(min(erri))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    if (B4[i][j][n][m] != i * NL / 10 + j * NL / 100 + n * NL / 1000 + m)
+                        erri = Min(erri, i * NL / 10 + j * NL / 100 + n * NL / 1000 + m);
+    #pragma dvm get_actual(erri)
+    s = 0;
+    cs = 0;
+    if (erri == ER && s == cs)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B4);
+    free(A4);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+    #undef k1i
+    #undef k2i
+    #undef k3i
+    #undef k4i
+    #undef li
+    #undef k1j
+    #undef k2j
+    #undef k3j
+    #undef k4j
+    #undef lj
+    #undef k1n
+    #undef k2n
+    #undef k3n
+    #undef k4n
+    #undef ln
+    #undef k1m
+    #undef k2m
+    #undef k3m
+    #undef k4m
+    #undef lm
+}
+/*-------------------------------------------------------*/
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REALIGN/realign11.cdv

@@ -0,0 +1,774 @@
+/*    REALIGN11
+Testing REALIGN directive */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void realign111();
+static void realign112();
+static void realign1121();
+static void realign112r();
+static void realign113();
+static void realign113r();
+static void realign114();
+static void realign1141();
+static void realign115();
+static void realign116();
+
+static void ansyes(const char tname[]);
+static void ansno (const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+
+static int erria, errib, i, j, ia, ib;
+
+int main(int an, char **as)
+{
+    printf("=== START OF REALIGN11 ======================\n");
+
+    /* ALIGN arrB[i] WITH arrA[i]  REALIGN arrB[i] WITH arrA[2*i+8] */
+    realign111();
+    /* ALIGN arrB[i] WITH arrA[i+4]  REALIGN arrB[i] WITH arrA[i+8] */
+    realign112();
+    /* ALIGN arrB[i] WITH arrA[i+2]  REALIGN arrB[i] WITH arrA[2*i+5] */
+    realign1121();
+    /* ALIGN arrB[i] WITH arrA[i+4]  REALIGN arrB[i] WITH arrA[-i+8] */
+//  realign112r();
+    /* ALIGN arrB[i] WITH arrA[3*i+2] REALIGN arrB[i] WITH arrA[2*i+1] */
+    realign113();
+    /* ALIGN arrB[i] WITH arrA[-i+8] REALIGN arrB[i] WITH arrA[3*i+2] */
+//  realign113r();
+    /* ALIGN arrB[i] WITH arrA[2*i+8]  REALIGN arrB[i] WITH arrA[i] */
+    realign114();
+    /* ALIGN arrB[i] WITH arrA[2*i]  REALIGN arrB[i] WITH arrA[i+2] */
+    realign1141();
+    /* ALIGN arrB[ ] WITH arrA[ ]  REALIGN arrB[i] WITH arrA[i+4] */
+    realign115();
+    /* ALIGN arrB[i] WITH arrA[4*i+3]  REALIGN arrB[] WITH arrA[] */
+    realign116();
+
+    printf ("=== END OF REALIGN11 ======================\n");
+    return 0;
+}
+
+/* ---------------------------------------------REALIGN111 */
+        /* ALIGN arrB[i] WITH arrA[i]  REALIGN arrB[i] WITH arrA[2*i+8] */
+void realign111()
+{
+    #define AN1 30
+    #define BN1 8
+
+/* parameters for ALIGN arrB[i] WITH arrA[k1i*i+li] */
+    int k1i = 1,li = 0;
+/* parameters for REALIGN arrB[i] WITH arrA[kr1i*i+lri] */
+    int kr1i = 2, lri = 8;   /* lri = -1 RTS err */
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+
+    char tname[] = "realign111 ";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i-li) == (((i-li)/k1i) * k1i)) &&
+           (((i-li)/k1i) >= 0) &&
+           (((i-li)/k1i) < BN1)) {
+                 ib = (i-li)/k1i;
+                 B1[ib] = ib;
+        }
+    }
+
+    } /* end region */
+
+    #pragma dvm realign (B1[i] with A1[kr1i * i + lri])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region inlocal(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i]) private(ia), reduction(min(erria), min(errib))
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != (i))
+            errib = Min(errib, i);
+        ia=kr1i * i + lri;
+        if (A1[ia] != (ia))
+            erria = Min(erria, i);
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------REALIGN112 */
+        /* ALIGN arrB[i] WITH arrA[i+4]  REALIGN arrB[i] WITH arrA[i+8] */
+void realign112()
+{
+    #define AN1 16
+    #define BN1 4
+
+/* parameters for ALIGN arrB[i] WITH arrA[k1i*i+li] */
+    int k1i = 1,li = 4;
+/* parameters for REALIGN arrB[i] WITH arrA[kr1i*i+lri] */
+    int kr1i = 1,lri = 8;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+
+    char tname[] = "realign112 ";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 1;
+
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i * 2;
+        if (((i-li) == (((i-li)/k1i) * k1i)) &&
+           (((i-li)/k1i) >= 0) &&
+           (((i-li)/k1i) < BN1)){
+              ib = (i-li)/k1i;
+              B1[ib] += ib;
+        }
+    }
+
+    } /* end region */
+
+    #pragma dvm realign(B1[i] with A1[kr1i * i + lri])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region inout(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i]) private(ia), reduction(min(erria), min(errib))
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != (i+1))
+            errib = Min(errib, i);
+        ia=kr1i * i + lri;
+        if (A1[ia] != ia*2)
+            erria = Min(erria, i);
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+       ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------REALIGN1121*/
+    /* ALIGN arrB[i] WITH arrA[i+2]  REALIGN arrB[i] WITH arrA[2*i+5] */
+void realign1121()
+{
+    int AN1 = 25;
+    int BN1 = 7;
+
+/* parameters for ALIGN arrB[i] WITH arrA[k1i*i+li] */
+    int k1i = 1;
+    int li = 4;
+/* parameters for REALIGN arrB[i] WITH arrA[kr1i*i+lri] */
+    int kr1i = 2;
+    int lri = 5;
+
+    char tname[] = "realign1121";
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array
+    int *B1;
+
+    A1 = malloc(sizeof(int[AN1]));
+    B1 = malloc(sizeof(int[BN1]));
+
+    #pragma dvm realign(B1[i] with A1[k1i * i + li])
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 2;
+    }
+
+    #pragma dvm region inout(B1), out(A1)
+    {
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] += ib;
+        }
+    }
+    }
+
+    #pragma dvm realign(B1[i] with A1[kr1i * i + lri])
+
+    #pragma dvm actual(erria, errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erria), min(errib)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i+2)
+            errib = Min(errib, i);
+        ia = kr1i * i + lri;
+        if (A1[ia] != ia)
+            erria = Min(erria, i);
+    }
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B1);
+    free(A1);
+}
+
+/* ---------------------------------------------REALIGN112r  */
+        /* ALIGN arrB[i] WITH arrA[i+4]  REALIGN arrB[i] WITH arrA[-i+8] */
+void realign112r()
+{
+    #define AN1 12
+    #define BN1 5
+
+/* parameters for ALIGN arrB[i] WITH arrA[k1i*i+li] */
+    int k1i = 1,li = 4;
+/* parameters for REALIGN arrB[i] WITH arrA[kr1i*i+lri] */
+    int kr1i = -1,lri = 8;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+
+    char tname[] = "realign112r ";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A1,B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i-li) == (((i-li)/k1i) * k1i)) &&
+           (((i-li)/k1i) >= 0) &&
+           (((i-li)/k1i) < BN1)){
+              ib = (i-li)/k1i;
+              B1[ib] = ib;
+        }
+    }
+
+    } /* end region */
+
+    #pragma dvm realign(B1[i] with A1[kr1i * i + lri])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region inout(A1,B1)
+    {
+    #pragma dvm parallel([i] on B1[i]) private(ia), reduction(min(erria), min(errib))
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != (i))
+            errib = Min(errib, i);
+        ia=kr1i * i + lri;
+        if (A1[ia] != (ia))
+            erria = Min(erria, i);
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef BN1
+}
+
+/* ---------------------------------------------REALIGN113 */
+        /* ALIGN arrB[i] WITH arrA[3*i+2] REALIGN arrB[i] WITH arrA[2*i+1] */
+void realign113()
+{
+    #define AN1 30
+    #define BN1 6
+
+/* parameters for ALIGN arrB[i] WITH arrA[k1i*i+li]  */
+    int k1i = 3,li = -2;   /* 3*i + (-2) - RTS err */
+/* parameters for REALIGN arrB[i] WITH arrA[kr1i*i+lri]  */
+    int kr1i = 2,lri = -1;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i - li])
+    int B1[BN1];
+
+    char tname[] = "realign113 ";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A1,B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 5;
+
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i+3;
+//        if (((i-li) == (((i-li)/k1i) * k1i)) &&
+//           (((i-li)/k1i) >= 0) &&
+//           (((i-li)/k1i) < BN1)) {
+//              ib = (i-li)/k1i;
+//              B1[ib] = B1[ib] + ib;
+//        }
+//    }
+        if (((i+li) == (((i+li)/k1i) * k1i)) &&
+           (((i+li)/k1i) >= 0) &&
+           (((i+li)/k1i) < BN1)) {
+              ib = (i+li)/k1i;
+              B1[ib] = B1[ib] + ib;
+        }
+    }
+
+    } /* end region */
+
+    #pragma dvm realign(B1[i] with A1[kr1i * i - lri])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region inout(A1,B1)
+    {
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erria), min(errib)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i+5)
+            errib = Min(errib, i);
+        ia=kr1i * i - lri;
+        if (A1[ia] != (ia+3))
+            erria = Min(erria, i);
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------REALIGN113r  */
+       /* ALIGN arrB[i] WITH arrA[-i+8] REALIGN arrB[i] WITH arrA[3*i+2] */
+void realign113r()
+{
+    #define AN1 18
+    #define BN1 5
+
+/* parameters for ALIGN arrB[i] WITH arrA[k1i*i+li]  */
+    int k1i = -1,li  = 8;
+/* parameters for REALIGN arrB[i] WITH arrA[kr1i*i+lri]  */
+    int kr1i = 3,lri  = 2;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+
+    char tname[] = "realign113r ";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A1,B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i-li) == (((i-li)/k1i) * k1i)) &&
+           (((i-li)/k1i) >= 0) &&
+           (((i-li)/k1i) < BN1)) {
+              ib = (i-li)/k1i;
+              B1[ib] = ib;
+        }
+    }
+
+    } /* end region */
+
+    #pragma dvm realign(B1[i] with A1[kr1i * i + lri])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erria),min(errib)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != (i))
+            errib = Min(errib, i);
+        ia=kr1i * i + lri;
+        if (A1[ia] != (ia))
+            erria = Min(erria, i);
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef BN1
+}
+
+/* ---------------------------------------------REALIGN114  */
+        /* ALIGN arrB[i] WITH arrA[2*i+8]  REALIGN arrB[i] WITH arrA[i] */
+void realign114()
+{
+    #define AN1 24
+    #define BN1 8
+
+/* parameters for ALIGN arrB[i] WITH arrA[k1i*i+li]  */
+    int k1i = 2, li = 8;
+/* parameters for REALIGN arrB[i] WITH arrA[kr1i*i+lri]  */
+    int kr1i = 1, lri = 0;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+
+    char tname[] = "realign114 ";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 0;
+
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i;
+        if (((i-li) == (((i-li)/k1i) * k1i)) &&
+           (((i-li)/k1i) >= 0) &&
+           (((i-li)/k1i) < BN1)) {
+              ib = (i-li)/k1i;
+              B1[ib] = ib;
+        }
+    }
+
+    } /* end region */
+
+    #pragma dvm realign(B1[i] with A1[kr1i * i + lri])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region inout(A1,B1)
+    {
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erria), min(errib)), private (ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != (i))
+            errib = Min(errib, i);
+        ia=kr1i * i + lri;
+        if (A1[ia] != (ia))
+            erria = Min(erria, i);
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef BN1
+}
+/* ------ ---------------------------------------REALIGN1141*/
+    /* ALIGN arrB[i] WITH arrA[4*i]  REALIGN arrB[i] WITH arrA[i+2] */
+void realign1141()
+{
+    int AN1 = 24;
+    int BN1 = 6;
+
+/* parameters for ALIGN arrB[i] WITH arrA[k1i*i+li]  */
+    int k1i = 4;
+    int li = 0;
+/* parameters for REALIGN arrB[i] WITH arrA[kr1i*i+lri]  */
+    int kr1i = 1;
+    int lri = 2;
+
+    char tname[] = "realign1141";
+
+    #pragma dvm array distribute[block]
+    int *A1;
+    #pragma dvm array
+    int *B1;
+
+    A1 = malloc(sizeof(int[AN1]));
+    B1 = malloc(sizeof(int[BN1]));
+
+    #pragma dvm realign(B1[i] with A1[k1i * i + li])
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region out(B1, A1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = 4;
+
+    #pragma dvm parallel([i] on A1[i]) private(ib)
+    for (i = 0; i < AN1; i++)
+    {
+        A1[i] = i+2;
+        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+            (((i - li) / k1i) >= 0) &&
+            (((i - li) / k1i) < BN1))
+        {
+            ib = (i - li) / k1i;
+            B1[ib] += ib;
+        }
+    }
+    }
+
+    #pragma dvm realign(B1[i] with A1[kr1i * i + lri])
+
+    #pragma dvm actual(erria, errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on B1[i]) reduction(min(erria), min(errib)), private(ia)
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != i+4)
+            errib = Min(errib, i);
+        ia = kr1i * i + lri;
+        if (A1[ia] != ia+2)
+            erria = Min(erria, i);
+    }
+    }
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B1);
+    free(A1);
+}
+/* ---------------------------------------------REALIGN115  */
+       /* ALIGN arrB[ ] WITH arrA[ ]  REALIGN arrB[i] WITH arrA[i+4] */
+void realign115()
+{
+    #define AN1 16
+    #define BN1 8
+
+/* parameters for ALIGN arrB[] WITH arrA[]  */
+    int k1i = 0,li  = 0;
+/* parameters for REALIGN arrB[i] WITH arrA[kr1i*i+lri]  */
+    int kr1i = 1,lri  = 4;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([] with A1[])
+    int B1[BN1];
+
+    char tname[] = "realign115 ";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = i;
+
+    #pragma dvm parallel([i] on A1[i])
+    for (i = 0; i < AN1; i++)
+        A1[i] = i;
+
+    } /* end region */
+
+    #pragma dvm realign(B1[i] with A1[kr1i * i + lri])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region inout(A1,B1)
+    {
+    #pragma dvm parallel([i] on B1[i]) private (ia), reduction(min(erria), min(errib))
+    for (i = 0; i < BN1; i++)
+    {
+        if (B1[i] != (i))
+            errib = Min(errib, i);
+        ia=kr1i * i + lri;
+        if (A1[ia] != (ia))
+            erria = Min(erria, i);
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef BN1
+}
+/* ---------------------------------------------REALIGN116 */
+       /* ALIGN arrB[i] WITH arrA[4*i+3]  REALIGN arrB[] WITH arrA[] */
+void realign116()
+{
+    #define AN1 35
+    #define BN1 8
+
+/* parameters for ALIGN arrB[i] WITH arrA[k1i*i+li]  */
+    int k1i = 4,li = 3;  /* 4*i-3  RTS err */
+/* parameters for REALIGN arrB[] WITH arrA[]  */
+    int kr1i = 0,lri = 0;
+
+    #pragma dvm array distribute[block]
+    int A1[AN1];
+    #pragma dvm array align([i] with A1[k1i*i+li])
+    int B1[BN1];
+
+    char tname[] = "realign116 ";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A1, B1)
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = i+6;
+
+    #pragma dvm parallel([i] on A1[i])
+    for (i = 0; i < AN1; i++)
+        A1[i] = (i+1)*3;
+
+    } /* end region */
+
+    #pragma dvm realign(B1[] with A1[])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region inout(A1,B1)
+    {
+    #pragma dvm parallel([i] on B1[i]) reduction(min(errib))
+    for (i = 0; i < BN1; i++)
+        if (B1[i] != i+6)
+            errib = Min(errib, i);
+    #pragma dvm parallel([i] on A1[i]) reduction(min(erria))
+    for (i = 0; i < AN1; i++)
+        if (A1[i] != (i+1)*3)
+            erria = Min(erria, i);
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef BN1
+}
+/*-------------------------------------------------------*/
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REALIGN/realign22.cdv

@@ -0,0 +1,855 @@
+/*    REALIGN22
+Testing REALIGN directive */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void realign221();
+static void realign222();
+static void realign223();
+static void realign224();
+static void realign225();
+static void realign226();
+static void realign227();
+static void realign228();
+static void realign229();
+
+static void ansyes(const char tname[]);
+static void ansno (const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+
+static int s, cs, erri, erria, errib, i, j, k, n, ia, ja, ib, jb;
+
+int main(int an, char **as)
+{
+    printf("=== START OF REALIGN22 ======================\n");
+
+    /* ALIGN arrB[i][j] WITH arrA[i][j]
+       REALIGN arrB[i][j] WITH arrA[3*i+2][2*j+1] */
+    realign221();
+    /* ALIGN arrB[i][j] WITH arrA[j+1][i]
+       REALIGN arrB[i][j] WITH arrA[i+4][j] */
+    realign222();
+    /* ALIGN arrB[i][*] WITH arrA[*][i]
+       REALIGN arrB[i][j] WITH arrA[i+4][j+4] */
+    realign223();
+    /* ALIGN arrB[*][*] WITH arrA[*][1]
+       REALIGN arrB[i][j] WITH arrA[i+4][j+4] */
+    realign224();
+    /* ALIGN arrB[i][j] WITH arrA[i][j]
+       REALIGN arrB[*][*] WITH arrA[*][2] */
+    realign225();
+    /* ALIGN arrB[i][j] WITH arrA[i][j]
+       REALIGN arrB[i][j] WITH arrA[2*j+1][3*i+2] */
+    realign226();
+    /* ALIGN arrB[*][*] WITH arrA[4][*]
+       REALIGN arrB[i][j] WITH arrA[i+2][2*j] */
+    realign227();
+    /* ALIGN arrB[i][j] WITH arrA[j][i]
+       REALIGN arrB[*][*] WITH arrA[3][*] */
+    realign228();
+    /* ALIGN arrB[i][j] WITH arrA[2*i][3*j+1]
+       REALIGN arrB[i][j] WITH arrA[j+6][i+2] */
+    realign229();
+
+    printf ("=== END OF REALIGN22 ======================\n");
+    return 0;
+}
+
+/* ---------------------------------------------REALIGN221 */
+        /* ALIGN arrB[i][j] WITH arrA[i][j]
+           REALIGN arrB[i][j] WITH arrA[3*i+2][2*j+1] */
+void realign221()
+{
+    #define AN1 16
+    #define AN2 16
+    #define BN1 4
+    #define BN2 4
+
+/* parameters for ALIGN arrB[i][j] WITH arrA[k1i*i+li][k2j*j+lj] */
+    int k1i = 1, li = 0;
+    int k2j = 1, lj = 0;
+/* parameters for REALIGN arrB[i][j] WITH arrA[kr1i*i+lri][kr2j*j+lrj] */
+    int kr1i = 3, lri = 2;
+    int kr2j = 2, lrj = 1;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k1i * i + li][k2j * j + lj])
+    int B2[BN1][BN2];
+
+    char tname[] = "realign221";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region in(A2,B2), out(A2,B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib,jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = (i*NL+j)*2;
+            if (
+                ((i-li) ==(((i-li)/k1i) * k1i)) &&
+                ((j-lj) ==(((j-lj)/k2j) * k2j)) &&
+                (((i-li)/k1i) >= 0)  &&
+                (((j-lj)/k2j) >= 0)  &&
+                (((i-li)/k1i) < BN1)  &&
+                (((j-lj)/k2j) < BN2)
+               )
+               {
+                    ib = (i-li)/k1i;
+                    jb = (j-lj)/k2j;
+                    B2[ib][jb]= B2[ib][jb] + ib*NL+jb;
+               }
+       }
+
+    } /* end region */
+
+    #pragma dvm realign(B2[i][j] with A2[kr1i * i + lri][kr2j * j + lrj])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region in(A2,B2), local(A2,B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erria),min(errib)), private(ia,ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i*NL+j))
+                errib = Min(errib, i*NL/10+j);
+
+            ia=kr1i * i + lri;
+            ja=kr2j * j + lrj;
+            if (A2[ia][ja] != (ia*NL+ja)*2)
+                erria = Min(erria, i*NL/10+j);
+        }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------REALIGN222 */
+        /* ALIGN arrB[i][j] WITH arrA[j+1][i]
+           REALIGN arrB[i][j] WITH arrA[i+4][j] */
+void realign222()
+{
+    #define AN1 8
+    #define AN2 8
+    #define BN1 4
+    #define BN2 4
+
+/* parameters for ALIGN arrB[i][j] WITH arrA[k2j*j+lj][k1i*i+li] */
+    int k1i = 1,li  = 0;
+    int k2j = 1,lj  = 1;
+/* parameters for REALIGN arrB[i][j] WITH arrA[kr1i*i+lri][kr2j*j+lrj] */
+    int kr1i = 1,lri  = 4;
+    int kr2j = 1,lrj  = 0;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k2j * j + lj][k1i * i + li])
+    int B2[BN1][BN2];
+
+    char tname[] = "realign222";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A2,B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 1;
+
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib), private(jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i*NL+j;
+            if (
+                ((i-lj) ==(((i-lj)/k2j) * k2j)) &&
+                ((j-li) ==(((j-li)/k1i) *k1i)) &&
+                (((i-lj)/k2j) >= 0)  &&
+                (((j-li)/k1i) >= 0)  &&
+                (((i-lj)/k2j) < BN2)  &&
+                (((j-li)/k1i) < BN1)
+               )
+               {
+                     ib = (j-li)/k1i;
+                     jb = (i-lj)/k2j;
+                     B2[ib][jb]=B2[ib][jb]+ib*NL+jb;
+               }
+        }
+
+    } /* end region */
+
+    #pragma dvm realign(B2[i][j] with A2[kr1i * i + lri][kr2j * j + lrj])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j]) private(ia,ja), reduction(min(erria),min(errib))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i*NL+j)+1)
+                errib = Min(errib, i*NL/10+j);
+            ia=kr1i * i + lri;
+            ja=kr2j * j + lrj;
+            if (A2[ia][ja] != (ia*NL+ja))
+                erria = Min(erria, i*NL/10+j);
+        }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------REALIGN223 */
+        /* ALIGN arrB[i][*] WITH arrA[*][i]
+           REALIGN arrB[i][j] WITH arrA[i+4][j+4] */
+void realign223()
+{
+    #define AN1 10
+    #define AN2 10
+    #define BN1 4
+    #define BN2 4
+
+/* parameters for ALIGN arrB[i][] WITH arrA[][k1i*i+li] */
+    int k1i = 1, li = 0;
+    int k2j = 0, lj = 0;
+/* parameters for REALIGN arrB[i][j] WITH arrA[kr1i*i+lri][kr2j*j+lrj] */
+    int kr1i = 1, lri  = 4;
+    int kr2j = 1, lrj  = 4;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][] with A2[][k1i * i + li])
+    int B2[BN1][BN2];
+
+    char tname[] = "realign223";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm actual (errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = i*NL+j+5;
+
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib,jb,k), reduction (min(errib))
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i*NL+j;
+            for (k = 0; k < BN2; k++)
+            {
+                if (
+                     ((j-li) ==(((j-li)/k1i) *k1i)) &&
+                     (((j-li)/k1i) >= 0)  &&
+                     (((j-li)/k1i) < BN1)
+                    )
+                {
+                    ib = ((j-li)/k1i);
+                    jb = k;
+                    if (B2[ib][jb] !=(ib*NL+jb+5))
+                        errib = Min(errib, i*NL/10+j);
+                }
+            }
+        }
+
+    } /* end region */
+
+    #pragma dvm realign(B2[i][j] with A2[kr1i * i + lri][kr2j * j + lrj])
+
+    #pragma dvm get_actual (errib)
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erria), min(errib)), private(ia,ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i*NL+j+5))
+                errib = Min(errib, i*NL/10+j);
+            ia=kr1i * i + lri;
+            ja=kr2j * j + lrj;
+            if (A2[ia][ja] != (ia*NL+ja))
+                erria = Min(erria, i*NL/10+j);
+        }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------REALIGN224 */
+        /* ALIGN arrB[*][*] WITH arrA[*][1]
+           ALIGN arrB[i][j] WITH arrA[i+4][j+4] shift along i and j */
+void realign224()
+{
+    #define AN1 12
+    #define AN2 14
+    #define BN1 5
+    #define BN2 6
+
+/* parameters for ALIGN arrB[][] WITH arrA[][lj] */
+    int k1i = 0, li  = 0;
+    int k2j = 0, lj  = 1;
+/* parameters for REALIGN arrB[i][j] WITH arrA[kr1i*i+lri][kr2j*j+lrj] */
+    int kr1i = 1, lri  = 4;
+    int kr2j = 1, lrj  = 4;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([][] with A2[][k2j * j + lj])
+    int B2[BN1][BN2];
+
+    char tname[] = "realign224";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm actual (errib)
+
+    #pragma dvm region inout(A2,B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = (i*NL+j)*2;
+
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib,jb,k,n), reduction(min(errib))
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i*NL+j+5;
+            if (j == (lj))
+                for (k = 0; k < BN1; k++)
+                    for (n = 0; n < BN2; n++)
+                    {
+                        ib = k;
+                        jb = n;
+                        if (B2[ib][jb] !=(ib*NL+jb)*2)
+                             errib = Min(errib, i*NL/10+j);
+                    }
+        }
+
+    } /* end region */
+
+    #pragma dvm realign(B2[i][j] with A2[kr1i * i + lri][kr2j * j + lrj])
+
+    #pragma dvm get_actual (errib)
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erria), min(errib)), private(ia,ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i*NL+j)*2)
+                   errib = Min(errib, i*NL/10+j);
+            ia=kr1i * i + lri;
+            ja=kr2j * j + lrj;
+            if (A2[ia][ja] != (ia*NL+ja+5))
+                   erria = Min(erria, i*NL/10+j);
+        }
+
+    } /* end region */
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------REALIGN225 */
+        /* ALIGN arrB[i][j] WITH arrA[i][j]
+           REALIGN arrB[*][*] WITH arrA[*][2] */
+void realign225()
+{
+    #define AN1 10
+    #define AN2 10
+    #define BN1 4
+    #define BN2 4
+
+/* parameters for ALIGN arrB[i][j] WITH arrA[k1i*i+li][k2j*j+lj] */
+    int k1i = 1, li  = 0;
+    int k2j = 1, lj  = 0;
+/* parameters for REALIGN arrB[][] WITH arrA[][lrj] */
+    int kr1i = 0, lri  = 0;
+    int kr2j = 0, lrj  = 2;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k1i * i + li][k2j * j + lj])
+    int B2[BN1][BN2];
+
+    char tname[] = "realign225";
+
+    errib = ER;
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib,jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i*NL+j;
+            if (
+                  ((i-li) ==(((i-li)/k1i) * k1i)) &&
+                  ((j-lj) ==(((j-lj)/k2j) *k2j)) &&
+                  (((i-li)/k1i) >= 0)  &&
+                  (((j-lj)/k2j) >= 0)  &&
+                  (((i-li)/k1i) < BN1)  &&
+                  (((j-lj)/k2j) < BN2)
+                  )
+            {
+                ib = (i-li)/k1i;
+                jb = (j-lj)/k2j;
+                B2[ib][jb]=ib*NL+jb;
+            }
+        }
+
+    } /* end region */
+
+    #pragma dvm realign(B2[][] with A2[][kr2j * j + lrj])
+
+    #pragma dvm actual (errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction (min(errib))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            if (B2[i][j] != (i*NL+j))
+                errib = Min(errib, i*NL/10+j);
+
+    } /* end region */
+
+    #pragma dvm get_actual(errib)
+
+    if (errib == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------REALIGN226 */
+    /* ALIGN arrB[i][j] WITH arrA[i][j]
+       REALIGN arrB[i][j] WITH arrA[2*j+1][3*i+2] */
+void realign226()
+{
+    #define AN1 16
+    #define AN2 18
+    #define BN1 6
+    #define BN2 4
+
+/* parameters for ALIGN arrB[i][j] WITH arrA[k1i*i+li][k2j*j+lj] */
+    int k1i = 1, li  = 0;
+    int k2j = 1, lj  = 0;
+/* parameters for REALIGN arrB[i][j] WITH arrA[kr2j*j+lrj][kr1i*i+lri] */
+    int kr1i = 3, lri  = 2;
+    int kr2j = 2, lrj  = 1;
+
+    #pragma dvm array distribute[block][block]
+    int A2[AN1][AN2];
+    #pragma dvm array align([i][j] with A2[k1i * i + li][k2j * j + lj])
+    int B2[BN1][BN2];
+
+    char tname[] = "realign226";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A2), in(B2), out(B2)
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+
+    } /* end region */
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib,jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = (i*NL+j)*3;
+            if (
+                ((i-li) ==(((i-li)/k1i) * k1i)) &&
+                ((j-lj) ==(((j-lj)/k2j) * k2j)) &&
+                (((i-li)/k1i) >= 0)  &&
+                (((j-lj)/k2j) >= 0)  &&
+                (((i-li)/k1i) < BN1)  &&
+                (((j-lj)/k2j) < BN2)
+                )
+            {
+                ib = (i-li)/k1i;
+                jb = (j-lj)/k2j;
+                B2[ib][jb]=ib*NL+jb;
+            }
+        }
+
+    } /* end region */
+
+    #pragma dvm realign(B2[i][j] with A2[kr2j*j+lrj][kr1i*i+lri])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erria),min(errib)),private(ia,ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i*NL+j))
+                errib = Min(errib, i*NL/10+j);
+            ia=kr2j * j + lrj;
+            ja=kr1i * i + lri;
+            if (A2[ia][ja] != (ia*NL+ja)*3)
+                erria = Min(erria,i*NL/10+j);
+        }
+
+    } /* end region */
+
+    #pragma dvm get_actual(errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef BN2
+}
+/* ---------------------------------------------REALIGN227 */
+    /* ALIGN B2[*][*] WITH arrA[4][*]
+       REALIGN B2[i][j] WITH arrA[i+2][2*j] */
+void realign227()
+{
+    int AN1 = 10;
+    int AN2 = 12;
+    int BN1 = 4;
+    int BN2 = 6;
+
+/* parameters for ALIGN arrB[][] WITH arrA[li][] */
+    int k1i = 0, li = 4;
+    int k2j = 0, lj = 0;
+/* parameters for REALIGN arrB[i][j] WITH arrA[kr1i*i+li][kr2j*j+lj] */
+    int kr1i = 1, lri = 2;
+    int kr2j = 2, lrj = 0;
+
+    char tname[] = "realign227";
+
+    #pragma dvm array distribute[block][block]
+    int (*A2)[AN2];
+    #pragma dvm array
+    int (*B2)[BN2];
+
+    A2 = malloc(sizeof(int[AN1][AN2]));
+    B2 = malloc(sizeof(int[BN1][BN2]));
+
+    #pragma dvm realign(B2[][] with A2[li][])
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([j][i] on A2[i][j]) private(ib, jb, k, n)
+    for (j = 0; j < AN2; j++)
+        for (i = 0; i < AN1; i++)
+        {
+            A2[i][j] = i * NL + j + 4;
+            if (i == li)
+                for (k = 0; k < BN1; k++)
+                    for (n = 0; n < BN2; n++)
+                    {
+                        ib = k;
+                        jb = n;
+                        B2[ib][jb] = ib * NL + jb + 7;
+                    }
+        }
+    }
+
+    #pragma dvm realign(B2[i][j] with A2[kr1i * i + lri][kr2j * j + lrj])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erria), min(errib)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j + 7))
+                errib = Min(errib, i*NL/10+j);
+            ia = kr1i * i + lri;
+            ja = kr2j * j + lrj;
+            if (A2[ia][ja] != (ia * NL + ja + 4))
+                erria = Min(erria, i*NL/10+j);
+        }
+    }
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B2);
+    free(A2);
+}
+/* ---------------------------------------------REALIGN228 */
+    /* ALIGN arrB[i][j] WITH arrA[j][i]
+       REALIGN arrB[*][*] WITH arrA[3][*] */
+void realign228()
+{
+    int AN1 = 14;
+    int AN2 = 8;
+    int BN1 = 4;
+    int BN2 = 3;
+
+/* parameters for ALIGN arrB[i][j] WITH arrA[k2j*j+lj][k1i*i+li] */
+    int k1i = 1, li = 0;
+    int k2j = 1, lj = 0;
+/* parameters for REALIGN arrB[][] WITH arrA[lri][] */
+    int kr1i = 0, lri = 3;
+    int kr2j = 0, lrj = 0;
+
+    char tname[] = "realign228";
+
+    #pragma dvm array distribute[block][block]
+    int (*A2)[AN2];
+    #pragma dvm array
+    int (*B2)[BN2];
+
+    A2 = malloc(sizeof(int[AN1][AN2]));
+    B2 = malloc(sizeof(int[BN1][BN2]));
+
+    #pragma dvm realign(B2[i][j] with A2[k2j * j + lj][k1i * i + li])
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 1;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (
+                ((i-lj) ==(((i-lj)/k2j) * k2j)) &&
+                ((j-li) ==(((j-li)/k1i) * k1i)) &&
+                (((i-lj)/k2j) >= 0)  &&
+                (((j-li)/k1i) >= 0)  &&
+                (((i-lj)/k2j) < BN2)  &&
+                (((j-li)/k1i) < BN1)
+               )
+            {
+                ib = (j-li)/k1i;
+                jb = (i-lj)/k2j;
+                B2[ib][jb] += ib*NL+jb;
+            }
+        }
+    }
+
+    #pragma dvm realign(B2[][] with A2[lri][])
+
+    #pragma dvm actual(errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(errib))
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            if (B2[i][j] != i * NL + j + 1)
+                errib = Min(errib, i*NL/10+j);
+    }
+
+    #pragma dvm get_actual(errib)
+
+    if (errib == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B2);
+    free(A2);
+}
+/* ---------------------------------------------REALIGN229 */
+    /* ALIGN B2[i][j] WITH arrA[2*i][3*j+1]
+       REALIGN B2[i][j] WITH arrA[j+6][i+2] */
+void realign229()
+{
+    int AN1 = 12;
+    int AN2 = 18;
+    int BN1 = 4;
+    int BN2 = 6;
+
+/* parameters for ALIGN arrB[i][j] WITH arrA[k1i*i+li][k2j*j+lj] */
+    int k1i = 2, li = 0;
+    int k2j = 3, lj = 1;
+/* parameters for REALIGN arrB[i][j] WITH arrA[kr2j*j+lrj][kr1i*i+lri] */
+    int kr1i = 1, lri = 2;
+    int kr2j = 1, lrj = 6;
+
+    char tname[] = "realign229";
+
+    #pragma dvm array distribute[block][block]
+    int (*A2)[AN2];
+    #pragma dvm array
+    int (*B2)[BN2];
+
+    A2 = malloc(sizeof(int[AN1][AN2]));
+    B2 = malloc(sizeof(int[BN1][BN2]));
+
+    #pragma dvm realign(B2[i][j] with A2[k1i * i + li][k2j * j + lj])
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            B2[i][j] = 0;
+    #pragma dvm parallel([i][j] on A2[i][j]) private(ib, jb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+        {
+            A2[i][j] = i * NL + j;
+            if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                (((i - li) / k1i) >= 0) &&
+                (((j - lj) / k2j) >= 0) &&
+                (((i - li) / k1i) < BN1) &&
+                (((j - lj) / k2j) < BN2))
+            {
+                ib = (i - li) / k1i;
+                jb = (j - lj) / k2j;
+                B2[ib][jb] = ib * NL + jb;
+            }
+        }
+    }
+
+    #pragma dvm realign(B2[i][j] with A2[kr2j * j + lrj][kr1i * i + lri])
+
+    #pragma dvm actual (erria, errib)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j]) reduction(min(erria), min(errib)), private(ia, ja)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+        {
+            if (B2[i][j] != (i * NL + j))
+                errib = Min(errib, i*NL/10+j);
+            ia=kr2j * j + lrj;
+            ja=kr1i * i + lri;
+            if (A2[ia][ja] != (ia * NL + ja))
+                erria = Min(erria, i*NL/10+j);
+         }
+    }
+
+    #pragma dvm get_actual(erria, errib)
+
+    if ((erria == ER) && (errib == ER))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B2);
+    free(A2);
+}
+
+/*-------------------------------------------------------*/
+
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REALIGN/realign33.cdv

@@ -0,0 +1,775 @@
+/*    REALIGN33
+Testing ALIGN and REALIGN directives */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void realign331();
+static void realign332();
+static void realign333();
+static void realign334();
+static void realign335();
+static void realign336();
+
+static void ansyes(const char tname[]);
+static void ansno (const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+
+static int s,cs,erria,errib,i,j,n,l,ia,ja,na,ib,jb,nb;
+
+int main(int an, char **as)
+{
+    printf("=== START OF REALIGN33 ===================\n");
+
+    /* ALIGN arrB3[i][j][n] WITH arrA3[i][j][n]
+       REALIGN arrB3[i][j][n] WITH arrA3[i+1][j+2][n+3] */
+    realign331();
+    /* ALIGN arrB3[i][j][n] WITH arrA3[i][j][n]
+       REALIGN arrB3[i][j][n] WITH arrA3[2*i][3*j][5*n] */
+    realign332();
+    /* ALIGN arrB3[i][j][n] WITH arrA3[i+2][j+4][n+3]
+       REALIGN arrB3[i][j][n] WITH arrA3[2*i+1][2*n][j+1] */
+    realign333();
+    /* ALIGN arrB3[i][j][n] WITH arrA3[n+1][3*i+1][j+2]
+       REALIGN arrB3[i][j][n] WITH arrA3[2*j][i+1][2*n+1] */
+    realign334();
+    /* ALIGN arrB[*][*][*] WITH arrA[*][*][*]
+       REALIGN arrB[i][j][n] WITH arrA[i][j][n] */
+    realign335();
+    /* ALIGN arrB[i][j][n] WITH arrA[i][j+1][2*n+1]
+       REALIGN arrB[*][j][n] WITH arrA[j+1][n][1] */
+    realign336();
+
+    printf("=== END OF REALIGN33 ===================\n");
+    return 0;
+}
+
+/* ----------------------------------------------------realign331 */
+    /* ALIGN arrB3[i][j][n]   WITH arrA3[i][j][n]
+       REALIGN arrB3[i][j][n] WITH arrA3[i+1][j+2][n+3] */
+
+void realign331()
+{
+    #define AN1 10
+    #define AN2 10
+    #define AN3 10
+    #define BN1 9
+    #define BN2 8
+    #define BN3 6
+
+/* parameters for ALIGN arrB[i][j][n] WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln] */
+    int k1i=1, li=0;
+    int k2j=1, lj=0;
+    int k3n=1, ln=0;
+/* parameters for REALIGN arrB[i][j][n] WITH arrA[kr1i*i+lri][kr2j*j+lrj][kr3n*n+lrn] */
+    int kr1i=1, lri=1;
+    int kr2j=1, lrj=2;
+    int kr3n=1, lrn=3;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j][n] with A3[k1i*i+li][k2j*j+lj][k3n*n+ln])
+    int B3[BN1][BN2][BN3];
+
+    char tname[] = "realign331";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A3,B3)
+    {
+
+//  A3 = 0;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                A3[i][j][n] = 0;
+
+//  B3 = 0;
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = 0;
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib,jb,nb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+    {
+                A3[i][j][n] = i*NL/10+j*NL/100+n*NL/1000;
+                if (((i-li) == (((i-li)/k1i) * k1i))  &&
+                    ((j-lj) == (((j-lj)/k2j) * k2j))  &&
+                    ((n-ln) == (((n-ln)/k3n) * k3n))  &&
+                    (((i-li)/k1i) >= 0)   &&
+                    (((j-lj)/k2j) >= 0)   &&
+                    (((n-ln)/k3n) >= 0)   &&
+                    (((i-li)/k1i) < BN1)  &&
+                    (((j-lj)/k2j) < BN2)  &&
+                    (((n-ln)/k3n) < BN3))
+                {
+                    ib = (i-li)/k1i;
+                    jb = (j-lj)/k2j;
+                    nb = (n-ln)/k3n;
+                    B3[ib][jb][nb]=ib*NL/10+jb*NL/100+nb*NL/1000;
+                }
+    } /* end of loop */
+
+    } /* end region */
+
+    #pragma dvm realign(B3[i][j][n] with A3[kr1i*i+lri][kr2j*j+lrj][kr3n*n+lrn])
+
+    s=0;
+
+    #pragma dvm actual (erria, errib, s)
+
+    #pragma dvm region inlocal(A3,B3)
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n]) reduction(min(erria),min(errib),sum(s)),private(ia,ja,na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+    {
+                s = s + B3[i][j][n];
+                if (B3[i][j][n] != (i*NL/10+j*NL/100+n*NL/1000))
+                    errib = Min(errib,i*NL/10 + j*NL/100 + n*NL/1000);
+                ia=kr1i * i + lri;
+                ja=kr2j * j + lrj;
+                na=kr3n * n + lrn;
+                if (A3[ia][ja][na] != (ia*NL/10+ja*NL/100+na*NL/1000))
+                    erria = Min(erria,ia*NL/10 + ja*NL/100 + na*NL/1000);
+    } /* end of loop */
+
+    } /* end region */
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                cs = cs + i*NL/10 + j*NL/100 + n*NL/1000;
+
+    #pragma dvm get_actual(erria, errib, s)
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+
+/*  ----------------------------------------------------realign332 */
+    /* ALIGN arrB3[i][j][n] WITH arrA3[i][j][n]
+       REALIGN arrB3[i][j][n] WITH arrA3[2*i][3*j][5*n] */
+
+void realign332()
+{
+    #define AN1 12
+    #define AN2 16
+    #define AN3 25
+    #define BN1 4
+    #define BN2 3
+    #define BN3 5
+
+/* parameters for ALIGN arrB[i][j][n] WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln] */
+    int k1i=1, li=0;
+    int k2j=1, lj=0;
+    int k3n=1, ln=0;
+/* parameters for REALIGN arrB[i][j][n] WITH arrA[kr1i*i+lri][kr2j*j+lrj][kr3n*n+lrn] */
+    int kr1i=2, lri=0;
+    int kr2j=3, lrj=0;
+    int kr3n=5, lrn=0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j][n] with A3[k1i*i+li][k2j*j+lj][k3n*n+ln])
+    int B3[BN1][BN2][BN3];
+
+    char tname[] = "realign332";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A3,B3)
+    {
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                A3[i][j][n] = 0;
+
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = 0;
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib,jb,nb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+    {
+                A3[i][j][n]=i*NL/10+j*NL/100+n*NL/1000 + 10;
+                if (
+                   ((i-li) == (((i-li)/k1i) * k1i)) &&
+                   ((j-lj) == (((j-lj)/k2j) *k2j))  &&
+                   ((n-ln) == (((n-ln)/k3n) * k3n)) &&
+                   (((i-li)/k1i) >= 0)  &&
+                   (((j-lj)/k2j) >= 0)  &&
+                   (((n-ln)/k3n) >= 0)  &&
+                   (((i-li)/k1i) < BN1)  &&
+                   (((j-lj)/k2j) < BN2)  &&
+                   (((n-ln)/k3n) < BN3)
+                   )
+                {
+                    ib = (i-li)/k1i;
+                    jb = (j-lj)/k2j;
+                    nb = (n-ln)/k3n;
+                    B3[i][j][n]=ib*NL/10+jb*NL/100+nb*NL/1000 + 5;
+                }
+    } /* end of loop */
+
+    } /* end region */
+
+    #pragma dvm realign(B3[i][j][n] with A3[kr1i*i+lri][kr2j*j+lrj][kr3n*n+lrn])
+
+    s=0;
+
+    #pragma dvm actual (erria, errib, s)
+
+    #pragma dvm region inlocal(A3),inlocal(B3)
+    {
+
+    #pragma dvm parallel([i][j][n] on B3[i][j][n]) reduction(min(erria), min(errib), sum(s)), private(ia, ja, na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++) {
+               s = s + B3[i][j][n];
+               if (B3[i][j][n] != (i*NL/10+j*NL/100+n*NL/1000) + 5)
+                   errib = Min(errib,i*NL/10 + j*NL/100 + n*NL/1000);
+               ia=kr1i * i + lri;
+               ja=kr2j * j + lrj;
+               na=kr3n * n + lrn;
+               if (A3[ia][ja][na] != (ia*NL/10+ja*NL/100+na*NL/1000)+10)
+                  erria = Min(erria,ia*NL/10 + ja*NL/100 + na*NL/1000);
+    } /* end of loop */
+
+    } /* end region */
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                cs = cs + i*NL/10 + j*NL/100 + n*NL/1000 + 5;
+
+    #pragma dvm get_actual(erria, errib, s)
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+/*  --------------------------------------------------realign333 */
+    /* ALIGN arrB3[i][j][n]   WITH arrA3[i+2][j+4][n+3]
+       REALIGN arrB3[i][j][n] WITH arrA3[2*i+1][2*n][j+1] */
+
+void realign333()
+{
+    #define AN1 12
+    #define AN2 16
+    #define AN3 25
+    #define BN1 4
+    #define BN2 3
+    #define BN3 5
+
+/* parameters for ALIGN arrB[i][j][n] WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln] */
+    int k1i=1, li=2;
+    int k2j=1, lj=4;
+    int k3n=1, ln=3;
+/* parameters for REALIGN arrB[i][j][n] WITH arrA[kr1i*i+lri][kr3n*n+lrn][kr2j*j+lrj] */
+    int kr1i=2, lri=1;
+    int kr2j=1, lrj=1;
+    int kr3n=2, lrn=0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j][n] with A3[k1i*i+li][k2j*j+lj][k3n*n+ln])
+    int B3[BN1][BN2][BN3];
+
+    char tname[] = "realign333";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A3),inout(B3)
+    {
+
+//  A3 = 1;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++) 
+                A3[i][j][n] = 1;
+
+//  B3 = 2;
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = 2;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib,jb,nb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+    {
+                A3[i][j][n] = A3[i][j][n] + i*NL/10+j*NL/100+n*NL/1000;
+                if (
+                   ((i-li) == (((i-li)/k1i) * k1i)) &&
+                   ((j-lj) == (((j-lj)/k2j) *k2j))  &&
+                   ((n-ln) == (((n-ln)/k3n) * k3n)) &&
+                   (((i-li)/k1i) >= 0)  &&
+                   (((j-lj)/k2j) >= 0)  &&
+                   (((n-ln)/k3n) >= 0)  &&
+                   (((i-li)/k1i) < BN1)  &&
+                   (((j-lj)/k2j) < BN2)  &&
+                   (((n-ln)/k3n) < BN3)
+                   )
+                {
+                    ib = (i-li)/k1i;
+                    jb = (j-lj)/k2j;
+                    nb = (n-ln)/k3n;
+                    B3[ib][jb][nb] += ib*NL/10+jb*NL/100+nb*NL/1000;
+                }
+    } /* end of loop */
+
+    } /* end region */
+
+    #pragma dvm realign(B3[i][j][n] with A3[kr1i*i+lri][kr3n*n+lrn][kr2j*j+lrj])
+
+    s=0;
+
+    #pragma dvm actual (erria, errib, s)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n]) reduction(min(erria),min(errib),sum(s)),private(ia,ja,na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+    {
+                s = s + B3[i][j][n];
+                if (B3[i][j][n] != (i*NL/10+j*NL/100+n*NL/1000) + 2)
+                    errib = Min(errib,i*NL/10 + j*NL/100 + n*NL/1000);
+                ia=kr1i * i + lri;
+                ja=kr3n * n + lrn;
+                na=kr2j * j + lrj;
+                if (A3[ia][ja][na] != (ia*NL/10+ja*NL/100+na*NL/1000)+1)
+                    erria = Min(erria,ia*NL/10 + ja*NL/100 + na*NL/1000);
+    } /* end of loop */
+
+    } /* end region */
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                cs = cs + i*NL/10 + j*NL/100 + n*NL/1000 + 2;
+
+    #pragma dvm get_actual(erria, errib, s)
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+
+/*  ----------------------------------------------------realign334 */
+    /* ALIGN arrB3[i][j][n] WITH arrA3[n+1][3*i+1][j+2]
+       REALIGN arrB3[i][j][n] WITH arrA3[2*j][i+1][2*n+1] */
+
+void realign334()
+{
+    #define AN1 15
+    #define AN2 28
+    #define AN3 20
+    #define BN1 4
+    #define BN2 6
+    #define BN3 6
+
+/* parameters for ALIGN arrB[i][j][n] WITH arrA[k3n*n+ln][k1i*i+li][k2j*j+lj] */
+    int k1i=3, li=1;
+    int k2j=1, lj=2;
+    int k3n=1, ln=1;
+/* parameters for REALIGN arrB[i][j][n] WITH arrA[kr2j*j+lrj][kr1i*i+lri][kr3n*n+lrn] */
+    int kr1i=1, lri=1;
+    int kr2j=2, lrj=0;
+    int kr3n=2, lrn=1;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j][n] with A3[k3n*n+ln][k1i*i+li][k2j*j+lj])
+    int B3[BN1][BN2][BN3];
+
+    char tname[] = "realign334";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region in(A3),in(B3),out(A3),out(B3)
+    {
+
+//  A3 = 0;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                A3[i][j][n] = 0;
+
+//  B3 = 0;
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = 0;
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib,jb,nb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+    {
+                A3[i][j][n] += i*NL/10+j*NL/100+n*NL/1000;
+                if (
+                   ((i-ln) == (((i-ln)/k3n) * k3n)) &&
+                   ((j-li) == (((j-li)/k1i) * k1i)) &&
+                   ((n-lj) == (((n-lj)/k2j) * k2j)) &&
+                   (((i-ln)/k3n) >= 0) &&
+                   (((j-li)/k1i) >= 0) &&
+                   (((n-lj)/k2j) >= 0) &&
+                   (((i-ln)/k3n) < BN3) &&
+                   (((j-li)/k1i) < BN1) &&
+                   (((n-lj)/k2j) < BN2)
+                  )
+                {
+                    ib = (j-li)/k1i;
+                    jb = (n-lj)/k2j;
+                    nb = (i-ln)/k3n;
+                    B3[ib][jb][nb] += ib*NL/10+jb*NL/100+nb*NL/1000;
+                }
+    } /* end of loop */
+
+    } /* end region */
+
+    #pragma dvm realign(B3[i][j][n] with A3[kr2j*j+lrj][kr1i*i+lri][kr3n*n+lrn])
+
+    s=0;
+
+    #pragma dvm actual (erria, errib, s)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n]) reduction(min(erria),min(errib),sum(s)),private(ia,ja,na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+    {
+                s += B3[i][j][n];
+                if (B3[i][j][n] != (i*NL/10+j*NL/100+n*NL/1000))
+                    errib = Min(errib,i*NL/10 + j*NL/100 + n*NL/1000);
+                ia=kr2j * j + lrj;
+                ja=kr1i * i + lri;
+                na=kr3n * n + lrn;
+                if (A3[ia][ja][na] != (ia*NL/10+ja*NL/100+na*NL/1000))
+                    erria = Min(erria,ia*NL/10 + ja*NL/100 + na*NL/1000);
+    } /* end of loop */
+
+    } /* end region */
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                cs = cs + i*NL/10 + j*NL/100 + n*NL/1000;
+
+    #pragma dvm get_actual(erria, errib, s)
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+
+/* ----------------------------------------------------realign335 */
+    /* ALIGN arrB[*][*][*] WITH arrA[*][*][*]
+       REALIGN arrB[i][j][n] WITH arrA[i][j][n] */
+
+void realign335()
+{
+    #define AN1 10
+    #define AN2 10
+    #define AN3 10
+    #define BN1 4
+    #define BN2 8
+    #define BN3 4
+
+/* parameters for  ALIGN arrB[*][*][*] WITH arrA[*][*][*] */
+    int k1i=0, li=0;
+    int k2j=0, lj=0;
+    int k3n=0, ln=0;
+/* parameters for REALIGN arrB[i][j][n] WITH arrA[kr1i*i+lri][kr2j*j+lrj][kr3n*n+lrn] */
+    int kr1i=1, lri=0;
+    int kr2j=1, lrj=0;
+    int kr3n=1, lrn=0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([][][] with A3[][][])
+    int B3[BN1][BN2][BN3];
+
+    char tname[] = "realign335";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm actual (A3, B3)
+
+    #pragma dvm region inout(B3)
+    {
+
+//  A3 = 0;
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                A3[i][j][n] = 0;
+
+//  B3 = 6;
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = 6;
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n])
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+    {
+                A3[i][j][n] += i*NL/10+j*NL/100+n*NL/1000;
+    } 
+
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+    {
+                 B3[i][j][n] = B3[i][j][n] + i*NL/10+j*NL/100+n*NL/1000;
+    } 
+
+    } /* end region */
+
+    #pragma dvm realign(B3[i][j][n] with A3[kr1i*i+lri][kr2j*j+lrj][kr3n*n+lrn])
+
+    s=0;
+
+    #pragma dvm actual (erria, errib, s)
+
+    #pragma dvm region inlocal(A3,B3)
+    {
+
+    #pragma dvm parallel([i][j][n] on B3[i][j][n]) reduction(min(erria),min(errib),sum(s)),private(ia,ja,na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+    {
+                s += B3[i][j][n];
+                if (B3[i][j][n] != (i*NL/10+j*NL/100+n*NL/1000)+ 6)
+                    errib = Min(errib,i*NL/10 + j*NL/100 + n*NL/1000);
+                ia=kr1i * i + lri;
+                ja=kr2j * j + lrj;
+                na=kr3n * n + lrn;
+                if (A3[ia][ja][na] != (ia*NL/10+ja*NL/100+na*NL/1000))
+                    erria = Min(erria,ia*NL/10 + ja*NL/100 + na*NL/1000);
+    } /* end of loop */
+
+    } /* end region */
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                cs = cs + i*NL/10 + j*NL/100 + n*NL/1000 + 6;
+
+    #pragma dvm get_actual(erria, errib, s)
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+
+/*  ----------------------------------------------------realign336 */
+    /* ALIGN arrB3[i][j][n] WITH arrA3[i][j+1][2*n+1]
+       REALIGN arrB3[*][j][n] WITH arrA[j+1][n][1] */
+
+void realign336()
+{
+    #define AN1 8
+    #define AN2 8
+    #define AN3 8
+    #define BN1 3
+    #define BN2 4
+    #define BN3 3
+
+/* parameters for ALIGN arrB[i][j][n] WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln] */
+    int k1i=1,li=0;
+    int k2j=1,lj=1;
+    int k3n=2,ln=1;
+/* parameters for REALIGN arrB[*][i][j] WITH arrA[kr2j*j+lrj][kr3n*n+lrn][lri] */
+    int kr1i=0,lri=1;
+    int kr2j=1,lrj=1;
+    int kr3n=1,lrn=0;
+
+    #pragma dvm array distribute[block][block][block]
+    int A3[AN1][AN2][AN3];
+    #pragma dvm array align([i][j][n] with A3[k1i*i+li][k2j*j+lj][k3n*n+ln])
+    int B3[BN1][BN2][BN3];
+
+    char tname[] = "realign336";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm actual (B3)
+
+    #pragma dvm region inout(B3), inout(A3)
+    {
+
+//  B3 = 0;
+    #pragma dvm parallel([i][j][n] on B3[i][j][n])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                B3[i][j][n] = 0;
+
+    #pragma dvm parallel([i][j][n] on A3[i][j][n]) private(ib,jb,nb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+    {
+                A3[i][j][n] = i*NL/10+j*NL/100+n*NL/1000;
+                if (
+                  ((i-li) == (((i-li)/k1i) * k1i)) &&
+                  ((j-lj) == (((j-lj)/k2j) *k2j))  &&
+                  ((n-ln) == (((n-ln)/k3n) * k3n)) &&
+                  (((i-li)/k1i) >= 0)  &&
+                  (((j-lj)/k2j) >= 0)  &&
+                  (((n-ln)/k3n) >= 0)  &&
+                  (((i-li)/k1i) < BN1)  &&
+                  (((j-lj)/k2j) < BN2)  &&
+                  (((n-ln)/k3n) < BN3)
+                  )
+                {
+                    ib = (i-li)/k1i;
+                    jb = (j-lj)/k2j;
+                    nb = (n-ln)/k3n;
+                    B3[ib][jb][nb]=ib*NL/10+jb*NL/100+nb*NL/1000;
+                }
+    } /* end of loop */
+
+    } /* end region */
+
+    #pragma dvm realign(B3[][j][n] with A3[kr2j*j+lrj][kr3n*n+lrn][lri])
+
+    s=0;
+
+    #pragma dvm actual (erria, errib, s)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n] on B3[i][j][n]) reduction(min(erria), min(errib), sum(s)), private(ia, ja, na)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+    {
+                s = s + B3[i][j][n];
+                if (B3[i][j][n] != (i*NL/10+j*NL/100+n*NL/1000))
+                    errib = Min(errib,i*NL/10 + j*NL/100+ n*NL/1000);
+                ia=kr2j*j+lrj;
+                ja=kr3n*n+lrn;
+                na=lri;
+                if (A3[ia][ja][na] != (ia*NL/10+ja*NL/100+na*NL/1000))
+                    erria = Min(erria,i*NL/10 + j*NL/100+ n*NL/1000);
+    } /* end of loop */
+
+    } /* end region */
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                cs = cs + i*NL/10 + j*NL/100+ n*NL/1000;
+
+    #pragma dvm get_actual(erria, errib, s)
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef BN1
+    #undef BN2
+    #undef BN3
+}
+
+/* ---------------------------------------------------- */
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+void ansno(const char name[])
+{
+    printf ("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REALIGN/realign44.cdv

@@ -0,0 +1,553 @@
+/*    REALIGN44
+Testing REALIGN directive */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+
+static void realign441();
+static void realign442();
+static void realign443();
+static void realign444();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 10000;
+static int ER = 100000;
+static int erria, errib, i, j, k, n, m, na, ma, ia, ib, nb, mb, ja, jb, s, cs;
+
+int main(int an, char **as)
+{
+    printf("=== START OF REALIGN44 ======================\n");
+
+    /* ALIGN arrB[i][j][n][m] WITH arrA[i][j][n][m]
+       REALIGN arrB[][j][n][] WITH arrA[j][n][1][3] */
+    realign441();
+    /* ALIGN arrB[][j][n][i] WITH arrA[i][j][][n]
+       REALIGN arrB[i][j][][m] WITH arrA[i][j][2][m] */
+    realign442();
+    /* ALIGN arrB[i][j][n][m] WITH arrA[i][2*j][3*n][4*m]
+       REALIGN arrB[i][j][n][m] WITH arrA[i+1][j+2]+[n+3][m+4] */
+    realign443();
+    /* ALIGN arrB[i][j][n][m] WITH arrA[m][i][j][n]
+       REALIGN arrB[i][j][n][m] WITH arrA[i+2][3*j+4][2*n+2][m+1] */
+    realign444();
+
+    printf("=== END OF REALIGN44 ========================\n");
+    return 0;
+}
+
+/* ---------------------------------------------REALIGN441*/
+    /* ALIGN arrB[i][j][n][m] WITH arrA[i][j][n][m]
+       REALIGN arrB[][j][n][] WITH arrA[j][n][1][3] */
+void realign441()
+{
+    #define AN1 6
+    #define AN2 8
+    #define AN3 5
+    #define AN4 7
+    #define BN1 2
+    #define BN2 5
+    #define BN3 4
+    #define BN4 3
+/*  parameters for ALIGN arrB[i][j][n][m] WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    int k1i = 1, li = 0;
+    int k2j = 1, lj = 0;
+    int k3n = 1, ln = 0;
+    int k4m = 1, lm = 0;
+/*  parameters for REALIGN arrB[*][j][n][*] WITH arrA[kr2j*j+lrj][kr3n*n+lrn][lri][lrm] */
+    int kr1i = 0, lri = 1;
+    int kr2j = 1, lrj = 0;
+    int kr3n = 1, lrn = 0;
+    int kr4m = 0, lrm = 3;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([i][j][n][m] with A4[k1i*i + li][k2j*j + lj][k3n*n + ln][k4m*m + lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "realign441";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                        ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                        ((n - ln) == (((n - ln) / k3n) * k3n)) &&
+                        ((m - lm) == (((m - lm) / k4m) * k4m)) &&
+                        (((i - li) / k1i) >= 0) &&
+                        (((j - lj) / k2j) >= 0) &&
+                        (((n - ln) / k3n) >= 0) &&
+                        (((m - lm) / k4m) >= 0) &&
+                        (((i - li) / k1i) < BN1) &&
+                        (((j - lj) / k2j) < BN2) &&
+                        (((n - ln) / k3n) < BN3) &&
+                        (((m - lm) / k4m) < BN4))
+                    {
+                        ib = (i - li) / k1i;
+                        jb = (j - lj) / k2j;
+                        nb = (n - ln) / k3n;
+                        mb = (m - lm) / k4m;
+                        B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+    }
+
+    #pragma dvm realign(B4[][j][n][] with A4[kr2j*j+lrj][kr3n*n+lrn][lri][lrm])
+
+    s = 0;
+
+    #pragma dvm actual(erria, errib, s)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erria), min(errib), sum(s)), private(ia, ja, na, ma)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s += B4[i][j][n][m];
+                    if (B4[i][j][n][m] !=val)
+                        errib = Min(errib, val);
+
+                    ia=kr2j*j+lrj;
+                    ja=kr3n*n+lrn;
+                    na=lri;
+                    ma=lrm;
+                    val = ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma;
+                    if (A4[ia][ja][na][ma] != val)
+                        erria = Min(erria, val);
+                }
+
+    }
+
+    #pragma dvm get_actual(erria, errib, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else {
+        ansno(tname);
+        printf ("%d, %d, %d\n", erria, errib, s);
+    }
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+
+/* ---------------------------------------------REALIGN442*/
+    /*  ALIGN arrB[][j][n][i] WITH arrA[i][j][][n]
+        REALIGN arrB[i][j][][m] WITH arrA[i][j][2][m] */
+void realign442()
+{
+    int AN1 = 5, AN2 = 5, AN3 = 5, AN4 = 5;
+    int BN1 = 2, BN2 = 2, BN3 = 2, BN4 = 2;
+
+/*  parameters for ALIGN arrB[*][j][n][i] WITH arrA4(k1i*i+li,k2j*j+lj,*,k3m*n+lm) */
+    int k1i = 1, li = 0;
+    int k2j = 1, lj = 0;
+    int k3n = 0, ln = 0;
+    int k3m = 1, lm = 0;
+/*  parameters for REALIGN arrB[i][j][*][m] WITH arrA(kr1i*i+lri,kr2j*j+lrj,lrn,kr4m*m+lrm) */
+    int kr1i = 1, lri = 0;
+    int kr2j = 1, lrj = 0;
+    int kr3n = 0, lrn = 2;
+    int kr4m = 1, lrm = 0;
+
+    char tname[] = "realign442";
+
+    #pragma dvm array distribute[block][block][block][block]
+    int (*A4)[AN2][AN3][AN4];
+    #pragma dvm array
+    int (*B4)[BN2][BN3][BN4];
+
+    A4 = malloc(sizeof(int[AN1][AN2][AN3][AN4]));
+    B4 = malloc(sizeof(int[BN1][BN2][BN3][BN4]));
+
+    #pragma dvm realign(B4[][j][n][i] with A4[k1i*i + li][k2j*j + lj][][k3m*n + lm])
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region inout(A4, B4)
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 0;
+
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb, k)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    for (k = 0; k < BN1; k++)
+                    {
+                        if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                            ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                            ((m - lm) == (((m - lm) / k3m) * k3m)) &&
+                            (((i - li) / k1i) >= 0) &&
+                            (((j - lj) / k2j) >= 0) &&
+                            (((m - lm) / k3m) >= 0) &&
+                            (((i - li) / k1i) < BN4) &&
+                            (((j - lj) / k2j) < BN2) &&
+                            (((m - lm) / k3m) < BN3))
+                        {
+                            mb = (i - li) / k1i;
+                            jb = (j - lj) / k2j;
+                            ib = k;
+                            nb = (m - lm) / k3m;
+                            B4[ib][jb][nb][mb] = ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                        }
+                    }
+                }
+    }
+
+    #pragma dvm realign(B4[i][j][][m] with A4[kr1i*i+lri][kr2j*j+lrj][lrn][kr4m*m+lrm])
+    s = 0;
+    #pragma dvm actual(erria, errib, s)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erria), min(errib), sum(s)), private(ia, ja, na, ma)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s += B4[i][j][n][m];
+                    if (B4[i][j][n][m] != val)
+                        errib = Min(errib,val);
+
+                    ia = kr1i*i + lri;
+                    ja = kr2j*j + lrj;
+                    na = lrn;
+                    ma = kr4m*m + lrm;
+                    val = ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma;
+                    if (A4[ia][ja][na][ma] != val)
+                        erria = Min(erria, val);
+                }
+
+    }
+    #pragma dvm get_actual(erria, errib, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+
+    // printf("erri = %u, ER = %u, s = %u, cs = %u\n", erri, ER, s, cs);
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B4);
+    free(A4);
+}
+
+/* ---------------------------------------------REALIGN443*/
+    /* ALIGN arrB[i][j][n][m] WITH arrA[i][2*j][3*n][4*m]
+       REALIGN arrB[i][j][n][m] WITH arrA[i+1][j+2]+[n+3][m+4] */
+
+void realign443()
+{
+    #define AN1 10
+    #define AN2 8
+    #define AN3 14
+    #define AN4 12
+    #define BN1 4
+    #define BN2 3
+    #define BN3 5
+    #define BN4 3
+/*  parameters for ALIGN arrB[i][j][n][m] WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm] */
+    int k1i = 1, li = 0;
+    int k2j = 2, lj = 0;
+    int k3n = 3, ln = 0;
+    int k4m = 4, lm = 0;
+/*  parameters for REALIGN arrB[i][j][n][m] WITH arrA[kr1i*i+lri][kr2j*j+lrj][kr3n*n+lrn][kr4m*m+lrm] */
+    int kr1i = 1, lri = 1;
+    int kr2j = 1, lrj = 2;
+    int kr3n = 1, lrn = 3;
+    int kr4m = 1, lrm = 4;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([i][j][n][m] with A4[k1i*i + li][k2j*j + lj][k3n*n + ln][k4m*m + lm])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "realign443";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 5;
+
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m + 1;
+                    if (((i - li) == (((i - li) / k1i) * k1i)) &&
+                        ((j - lj) == (((j - lj) / k2j) * k2j)) &&
+                        ((n - ln) == (((n - ln) / k3n) * k3n)) &&
+                        ((m - lm) == (((m - lm) / k4m) * k4m)) &&
+                        (((i - li) / k1i) >= 0) &&
+                        (((j - lj) / k2j) >= 0) &&
+                        (((n - ln) / k3n) >= 0) &&
+                        (((m - lm) / k4m) >= 0) &&
+                        (((i - li) / k1i) < BN1) &&
+                        (((j - lj) / k2j) < BN2) &&
+                        (((n - ln) / k3n) < BN3) &&
+                        (((m - lm) / k4m) < BN4))
+                    {
+                        ib = (i - li) / k1i;
+                        jb = (j - lj) / k2j;
+                        nb = (n - ln) / k3n;
+                        mb = (m - lm) / k4m;
+                        B4[ib][jb][nb][mb] += ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+    }
+
+    #pragma dvm realign(B4[i][j][n][m] with A4[kr1i*i + lri][kr2j*j + lrj][kr3n*n + lrn][kr4m*m + lrm])
+
+    s = 0;
+
+    #pragma dvm actual(erria, errib, s)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erria), min(errib), sum(s)), private(ia, ja, na, ma)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s += B4[i][j][n][m];
+                    if (B4[i][j][n][m] != val + 5)
+                        errib = Min(errib, val);
+
+                    ia=kr1i*i+lri;
+                    ja=kr2j*j+lrj;
+                    na=kr3n*n+lrn;
+                    ma=kr4m*m+lrm;
+                    val = ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma;
+                    if (A4[ia][ja][na][ma] != val + 1)
+                        erria = Min(erria, val);
+                }
+
+    }
+
+    #pragma dvm get_actual(erria, errib, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m + 5;
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf ("%d, %d, %d\n", erria, errib, s);
+    }
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+
+/* ---------------------------------------------REAGLIGN444*/
+    /* ALIGN arrB[i][j][n][m] WITH arrA[m][i+1][j][2*n]
+       REALIGN arrB[i][j][n][m] WITH arrA[i+2][3*j+4][2*n+2][m+1] */
+
+void realign444()
+{
+    #define AN1 12
+    #define AN2 15
+    #define AN3 16
+    #define AN4 10
+    #define BN1 4
+    #define BN2 4
+    #define BN3 5
+    #define BN4 3
+/*  parameters for ALIGN arrB[i][j][n][m] WITH arrA4[k4m*m+lm][k1i*i+li][k2j*j+lj][k3n*n+ln] */
+    int k1i = 1, li = 1;
+    int k2j = 1, lj = 0;
+    int k3n = 2, ln = 0;
+    int k4m = 1, lm = 0;
+/*  parameters for REALIGN arrB[i][j][n][m] WITH arrA[kr1i*i+lri][kr2j*j+lrj][kr3n*n+lrn][kr4m*m+lrm] */
+    int kr1i = 1, lri = 2;
+    int kr2j = 3, lrj = 4;
+    int kr3n = 2, lrn = 2;
+    int kr4m = 1, lrm = 1;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int A4[AN1][AN2][AN3][AN4];
+    #pragma dvm array align([i][j][n][m] with A4[k4m*m+lm][k1i*i+li][k2j*j+lj][k3n*n+ln])
+    int B4[BN1][BN2][BN3][BN4];
+    char tname[] = "realign444";
+
+    erria = ER;
+    errib = ER;
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m])
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    B4[i][j][n][m] = 4;
+
+    #pragma dvm parallel([i][j][n][m] on A4[i][j][n][m]) private(ib, jb, nb, mb)
+    for (i = 0; i < AN1; i++)
+        for (j = 0; j < AN2; j++)
+            for (n = 0; n < AN3; n++)
+                for (m = 0; m < AN4; m++)
+                {
+                    A4[i][j][n][m] = 10 + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    if (
+                       ((i-lm) == (((i-lm)/k4m) * k4m)) &&
+                       ((j-li) == (((j-li)/k1i) * k1i)) &&
+                       ((n-lj) == (((n-lj)/k2j) * k2j)) &&
+                       ((m-ln) == (((m-ln)/k3n) * k3n)) &&
+                       (((i-lm)/k4m) >= 0) &&
+                       (((j-li)/k1i) >= 0) &&
+                       (((n-lj)/k2j) >= 0) &&
+                       (((m-ln)/k3n) >= 0) &&
+                       (((i-lm)/k4m) < BN4)&&
+                       (((j-li)/k1i) < BN1) &&
+                       (((n-lj)/k2j) < BN2) &&
+                       (((m-ln)/k3n) < BN3)
+                      )
+                    {
+                        ib = (j-li)/k1i;
+                        jb = (n-lj)/k2j;
+                        nb = (m-ln)/k3n;
+                        mb = (i-lm)/k4m;
+                        B4[ib][jb][nb][mb] += ib * NL / 10 + jb * NL / 100 + nb * NL / 1000 + mb;
+                    }
+                }
+
+    } /* end region */
+
+    #pragma dvm realign(B4[i][j][n][m] with A4[kr1i*i + lri][kr2j*j + lrj][kr3n*n + lrn][kr4m*m + lrm])
+
+    s = 0;
+
+    #pragma dvm actual(erria, errib, s)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j][n][m] on B4[i][j][n][m]) reduction(min(erria), min(errib), sum(s)), private(ia, ja, na, ma)
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                {
+                    int val = i * NL / 10 + j * NL / 100 + n * NL / 1000 + m;
+                    s += B4[i][j][n][m];
+                    if (B4[i][j][n][m] != val+4)
+                        errib = Min(errib, val);
+
+                    ia=kr1i*i+lri;
+                    ja=kr2j*j+lrj;
+                    na=kr3n*n+lrn;
+                    ma=kr4m*m+lrm;
+                    val = ia * NL / 10 + ja * NL / 100 + na * NL / 1000 + ma;
+                    if (A4[ia][ja][na][ma] != val+10)
+                        erria = Min(erria, val);
+                }
+    }
+
+    #pragma dvm get_actual(erria, errib, s)
+
+    cs = 0;
+    for (i = 0; i < BN1; i++)
+        for (j = 0; j < BN2; j++)
+            for (n = 0; n < BN3; n++)
+                for (m = 0; m < BN4; m++)
+                    cs = cs + i * NL / 10 + j * NL / 100 + n * NL / 1000 + m + 4;
+
+    if ((erria == ER) && (errib == ER) && (s == cs))
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+}
+/* --------------------------------------------- */
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REDUCTION/red11n.cdv

@@ -0,0 +1,995 @@
+/*  Testing  REDUCTION clause
+    REDUCTION operations: SUM,PRODUCT,MAX,MIN,AND,OR,MAXLOC,MINLOC and
+    their combinations are executed
+    for distributed array A(N)
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void red1101();
+static void red1102();
+static void red1103();
+static void red1104();
+static void red1105();
+static void red1106();
+static void red1107();
+static void red1108();
+static void red1111();  /* tests 109-110 are absent */
+static void red1112();
+static void red1113();
+static void red1114();
+static void red1115();
+static void red1116();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int sersum1(int *AR, int N, int NL);
+static int sersum1m(int *AR, int N, int NL);
+static float sers1mr(float *RAR, int N, float RNL);
+static int serprod1(int *AR, int N, int NL);
+static float serprodr1(float *AR, int N, float RNL);
+static int serand1(int *AR, int N);
+static int seror1(int *AR, int N);
+
+int main(int an, char **as)
+{
+    printf("===START OF red11n ========================\n");
+
+    red1101();
+    red1102();
+    red1103();
+    red1104();
+    red1105();
+    red1106();
+    red1107();
+    red1108();
+    red1111();
+    red1112();
+    red1113();
+    red1114();
+    red1115();
+    red1116();
+
+    printf("=== END OF red11n ========================= \n");
+    return 0;
+}
+
+/* ---------------------------------------------RED1101 */
+void red1101()
+{
+    #define N 32
+    #define NL 1000
+
+    int C[N];
+    int i, isum1, isumt1;
+
+    char tname[] = "RED1101";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    isum1 = sersum1(C, N, NL);
+    isumt1=0;
+
+    #pragma dvm actual(isumt1)
+
+    #pragma dvm region inout(A)
+    {
+
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL+i;
+
+    #pragma dvm parallel([i] on A[i]) reduction(sum(isumt1))
+    for (i = 0; i < N; i++)
+        isumt1 = isumt1 + A[i];
+
+    } /* end region */
+
+    #pragma dvm get_actual(isumt1)
+
+    if (isum1 == isumt1)
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf("isum1=%d isumt1=%d\n",isum1,isumt1);
+    }
+
+    #undef N
+    #undef NL
+}
+
+/* ---------------------------------------------RED1102  */
+void red1102()
+ {
+    #define N 15
+    #define NL 2
+
+    int C[N];
+    int i;
+    int iprod1, iprodt1;
+    char tname[] = "RED1102";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    iprod1 = serprod1(C, N, NL);
+
+    iprodt1 = 1;
+
+    #pragma dvm actual(iprodt1)
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    #pragma dvm parallel([i] on A[i]) reduction(product(iprodt1))
+    for (i = 0; i < N; i++)
+        iprodt1 = iprodt1 * A[i];
+
+    } /* end region */
+
+    #pragma dvm get_actual(iprodt1)
+
+    if (iprod1 == iprodt1)
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf ("iprod1 = %d, iprodt1 = %d\n", iprod1, iprodt1);
+    }
+
+    #undef N
+    #undef NL
+}
+
+/* ---------------------------------------------RED1103  */
+void red1103()
+{
+    #define N 30
+    #define NL 1003
+
+    int C[N];
+    int i, imax1, imaxt1, ni;
+    char tname[] = "RED1103";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    ni = N / 2 - 1;
+    A[ni] = N + 1 + NL;
+
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[1])
+    {
+    imaxt1 = A[1];
+    }
+    #pragma dvm actual(imaxt1)
+    } /* end host_section */
+
+    #pragma dvm parallel([i] on A[i]) reduction(max(imaxt1))
+    for (i = 0; i < N; i++)
+        if (A[i] > imaxt1) imaxt1 = A[i];
+
+    } /* end region */
+
+    #pragma dvm get_actual(imaxt1)
+
+    imax1 = N + 1 + NL;
+
+    if (imax1 == imaxt1)
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf("imax1=%d imaxt1=%d\n",imax1,imaxt1);
+    }
+
+    #undef N
+    #undef NL
+}
+
+/* ---------------------------------------------RED1104  */
+void red1104()
+{
+    #define N 16
+    #define NL 1004
+    int C[N];
+    int i, imin1, imint1, ni;
+    char tname[] = "RED1104";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    } /* end region */
+
+    #pragma dvm remote_access(A[1])
+    {
+    imint1 = A[1];
+    }
+
+    ni = N / 2 + 1;
+    A[ni] = -(N + 1 + NL);
+    imin1 = -(N + 1 + NL);
+
+    #pragma dvm actual(imint1, A[ni])
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i]) reduction(min(imint1))
+    for (i = 0; i < N; i++)
+        if (A[i] < imint1) imint1 = A[i];
+    } /* end region */
+
+    #pragma dvm get_actual(imint1)
+
+    if (imin1 == imint1)
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf("imin1=%d imint1=%d\n",imin1,imint1);
+    }
+
+    #undef N
+    #undef NL
+}
+
+/* ---------------------------------------------RED1105 */
+void red1105()
+{
+    #define N 32
+    #define RNL 1005.
+
+    float C[N];
+    int i, ni;
+    float imax1, imaxt1;
+    char tname[] = "RED1105";
+
+    #pragma dvm array distribute[block]
+    float A[N];
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = RNL + i;
+
+    ni = N / 2 - 1;
+    A[ni] = N + 1. + RNL;
+    imax1 = N + 1. + RNL;
+
+    } /* end region */
+
+    #pragma dvm get_actual(imax1)
+
+    #pragma dvm remote_access(A[1])
+    {
+    imaxt1 = A[1];
+    }
+
+    #pragma dvm actual(imaxt1)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i]) reduction(max(imaxt1))
+    for (i = 0; i < N; i++)
+        if (A[i] > imaxt1) imaxt1=A[i];
+
+    } /* end region */
+
+    #pragma dvm get_actual(imaxt1)
+
+    if (imax1 == imaxt1)
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf("imax1=%f imaxt1=%f\n",imax1,imaxt1);
+    }
+
+    #undef N
+    #undef RNL
+}
+
+/* ---------------------------------------------RED1106  */
+void red1106()
+{
+    #define N 11
+    float RNL = 1.;
+
+    float C[N];
+    int i;
+    float iprod1, iprodt1;
+    char tname[] = "RED1106";
+
+    #pragma dvm array distribute[block]
+    float A[N];
+
+    iprod1 = serprodr1(C, N, RNL);
+    iprodt1 = 1.;
+
+    #pragma dvm actual(iprodt1)
+
+    #pragma dvm region out(A)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = RNL + i;
+
+    #pragma dvm parallel([i] on A[i]) reduction(product(iprodt1))
+    for (i = 0; i < N; i++)
+       iprodt1 = iprodt1 * A[i];
+
+    } /* end region */
+
+    #pragma dvm get_actual(iprodt1)
+
+    if (iprod1 == iprodt1)
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf ("iprod1 = %f, iprodt1 = %f\n",  iprod1, iprodt1);
+    }
+
+    #undef N
+}
+
+/* ---------------------------------------------RED1107 */
+void red1107()
+{
+    #define N 31
+
+    int CL[N];
+    int i;
+    int land1, landt1;
+    char tname[] = "RED1107";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    land1 = serand1(CL, N);
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i+=2)
+        A[i] = 1;
+
+    #pragma dvm parallel([i] on A[i])
+    for (i = 1; i < N; i+=2)
+        A[i] = 0;
+
+    } /* end region */
+
+//    # pragma dvm get_actual(A)
+
+    #pragma dvm remote_access(A[1])
+    {
+    landt1 = A[1];
+    }
+
+    #pragma dvm actual(landt1)
+
+    #pragma dvm region inlocal(A)
+    {
+    #pragma dvm parallel([i] on A[i]) reduction(and(landt1))
+    for (i = 0; i < N; i++)
+       landt1 = landt1 && A[i];
+
+    } /* end region */
+
+    #pragma dvm get_actual(landt1)
+
+    if (land1 == landt1)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+}
+
+/* ---------------------------------------------RED1108  */
+void red1108()
+{
+    #define N 17
+
+    int CL[N];
+    int i;
+    int lor1,lort1;
+    char tname[] = "RED1108";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    lor1 = seror1(CL, N);
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = i % 2;
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[1])
+    {
+    lort1 = A[1];
+    }
+    #pragma dvm actual(lort1)
+    }
+
+    #pragma dvm parallel([i] on A[i]) reduction(or(lort1))
+    for (i = 0; i < N; i++)
+       lort1 = lort1 || A[i];
+
+    } /* end region */
+
+    #pragma dvm get_actual(lort1)
+
+    if (lor1 == lort1)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+}
+
+/* ---------------------------------------------RED1111 */
+void red1111()
+{
+    #define N 32
+    #define NL 1000
+
+    int C[N];
+    int i, imaxloc1, imaxloct1, it1, ni;
+    char tname[] = "RED1111";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+
+    ni = N / 2 + 1;
+    A[ni] = N + 1 + NL;
+    imaxloc1 = N + 1 + NL;
+
+    #pragma dvm remote_access(A[0])
+    {
+    imaxloct1 = A[0];
+    }
+
+    #pragma dvm actual(imaxloct1)
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i]) reduction(maxloc(imaxloct1, it1))
+    for (i = 0; i < N; i++)
+        if (A[i] > imaxloct1) {
+            imaxloct1 = A[i];
+            it1 = i;
+        }
+    } /* end region */
+
+    #pragma dvm get_actual(imaxloct1,it1)
+
+    if ((imaxloct1 == imaxloc1) && (it1 == ni))
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf("imax1=%d imaxt1=%d imaxloct1=%d it1=%d ni=%d\n",
+//             imax1,imaxt1,imaxloct1,it1,ni);
+    }
+
+    #undef N
+    #undef NL
+}
+
+/* ---------------------------------------------RED1112  */
+void red1112()
+{
+    #define N 27
+    int NL = 1012;
+    int C[N];
+    int i, ni, iminloc1, iminloct1,it2;
+    char tname[] = "RED1112";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+    } /* end region */
+
+    #pragma dvm get_actual(A)
+
+    ni = N / 2 + 2;
+    A[ni] = - (N + 1 + NL);
+    #pragma dvm actual(A[ni])
+    iminloc1 = -(N + 1 + NL);
+
+    #pragma dvm remote_access(A[3])
+    {
+    iminloct1=A[3];
+    }
+
+    #pragma dvm actual(iminloct1)
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i]) reduction(minloc(iminloct1, it2))
+    for (i = 0; i < N; i++)
+        if (A[i] < iminloct1) {
+           iminloct1 = A[i];
+           it2 = i;
+        }
+    } /* end region */
+
+    #pragma dvm get_actual(iminloct1, it2)
+
+    if ((iminloct1 == iminloc1) && (it2 == ni))
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf("imin1=%d imint1=%d iminloct1=%d it2=%d ni=%d\n",
+//              imin1,imint1,iminloct1,it2,ni);
+    }
+
+    #undef N
+}
+
+/* ---------------------------------------------RED1113 */
+void red1113()
+{
+    #define N 24
+    #define NL 1003
+
+    int C[N];
+    int i, isum1, isumt1, imax1, imaxt1, imin1, imint1, ni;
+    char tname[] = "RED1113";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    isum1 = sersum1m(C, N, NL);
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL+i;
+    } /* end region */
+
+    ni = N / 2 - 2;
+    A[ni] = N + 1 + NL;
+    #pragma dvm actual(A[ni])
+
+    imax1 = N + 1 + NL;
+
+    #pragma dvm remote_access(A[1])
+    {
+    imaxt1 = A[1];
+    }
+
+    ni = N / 2;
+    A[ni] = -(N + 1 + NL);
+    #pragma dvm actual(A[ni])
+
+    imin1 = -(N + 1 + NL);
+    imint1 = imaxt1;
+
+    isumt1 = 0;
+
+    #pragma dvm actual(isumt1, imaxt1, imint1)
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i]) reduction(sum(isumt1), max(imaxt1), min(imint1))
+    for (i = 0; i < N; i++)
+    {
+        isumt1 = isumt1 + A[i];
+        if (A[i] > imaxt1) imaxt1 = A[i];
+        if (A[i] < imint1) imint1 = A[i];
+    }
+    } /* end region */
+
+    #pragma dvm get_actual(isumt1, imaxt1, imint1)
+
+    if ((isum1 == isumt1) && (imax1 == imaxt1) && (imin1 == imint1))
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf("isum1=%d isumt1=%d\n",isum1,isumt1);
+//      printf("imax1=%d imaxt1=%d\n",imax1,imaxt1);
+//      printf("imin1=%d imint1=%d\n",imin1,imint1);
+    }
+
+    #undef N
+    #undef NL
+}
+
+/* ---------------------------------------------RED1114  */
+void red1114()
+{
+    #define N 13
+    #define NL 2
+
+    int C[N],CL[N];
+    char tname[] = "RED1114";
+    int i;
+    int iprod1, iprodt1;
+    int land1, landt1;
+
+    #pragma dvm array distribute[block]
+    int A[N];
+    #pragma dvm array align([i] with A[i])
+    int B[N];
+
+    iprod1 = serprod1(C, N, NL);
+    land1 = serand1(CL, N);
+
+    #pragma dvm region inout(A)
+    {
+
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL + i;
+    #pragma dvm parallel([i] on B[i])
+    for (i = 0; i < N; i++)
+        B[i] = i%2;
+    } /* end region */
+
+//    #pragma dvm get_actual (B[1])
+
+    #pragma dvm remote_access(B[1])
+    {
+    landt1 = B[1];
+    }
+
+    iprodt1 = 1;
+
+    #pragma dvm actual (landt1, iprodt1)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on A[i]) reduction(product(iprodt1), and(landt1))
+    for (i = 0; i < N; i++)
+    {
+       iprodt1 = iprodt1 * A[i];
+       landt1 = landt1 && B[i];
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(iprodt1, landt1)
+
+    if ((iprod1 == iprodt1) && (land1 == landt1))
+       ansyes(tname);
+    else
+    {
+       ansno(tname);
+//     printf ("iprod1 = %f, iprodt1 = %f\n", iprod1, iprodt1);
+    }
+
+    #undef N
+    #undef NL
+}
+
+/* ---------------------------------------------RED1115  */
+void red1115()
+{
+    #define N 22
+    #define NL 1015
+
+    int C[N];
+    int i, imax1, imaxt1, imin1, ni1, ni2;
+    int imaxloct1, iminloct1, it1, it2;
+    char tname[] = "RED1115";
+
+    #pragma dvm array distribute[block]
+    int A[N];
+
+    #pragma dvm region inout(A)
+    {
+
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = NL+i;
+
+    } /* end region */
+
+    ni1 = N / 2 - 3;
+    A[ni1] = N + 1 + NL;
+    imax1 = N + 1 + NL;
+
+    ni2 = N / 2 + 2;
+    A[ni2] = -(N + 1 + NL);
+    imin1 = -(N + 1 + NL);
+
+    #pragma dvm remote_access(A[1])
+    {
+    imaxt1=A[1];
+    }
+
+    imaxloct1 = imaxt1;
+    iminloct1 = imaxloct1;
+
+    #pragma dvm actual(A[ni1], A[ni2], imaxt1, imaxloct1, iminloct1)
+
+    #pragma dvm region inout(A)
+    {
+    #pragma dvm parallel([i] on A[i]) reduction(max(imaxt1),maxloc(imaxloct1,it1), minloc(iminloct1,it2))
+    for (i = 0; i < N; i++)
+    {
+        if (A[i] > imaxt1) imaxt1 = A[i];
+        if (A[i] > imaxloct1)
+        {
+            imaxloct1 = A[i];
+            it1 = i;
+        }
+        if (A[i] < iminloct1)
+        {
+            iminloct1 = A[i];
+            it2 = i;
+        }
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(imaxt1, imaxloct1, it1, iminloct1, it2)
+
+    if ((imaxloct1 == imax1) && (iminloct1 == imin1) &&
+       (imaxt1 == imaxloct1) && (it1 == ni1) && (it2 == ni2))
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf("imax1=%d imaxt1=%d imaxloct1=%d it1=%d ni1=%d\n",
+//              imax1,imaxt1,imaxloct1,it1,ni1);
+//      printf("imin1=%d  iminloct1=%d it2=%d ni2=%d\n",
+//              imin1,iminloct1,it2,ni2);
+    }
+
+    #undef N
+    #undef NL
+}
+
+/* ---------------------------------------------RED1116  */
+void red1116()
+{
+    #define N 28
+    #define RNL 1016.
+
+    float C[N];
+    int i, ni1, ni2, it1, it2;
+    float isum1, isumt1, imax1, imin1;
+    float imaxloct1, iminloct1;
+    char tname[] = "RED1116";
+
+    #pragma dvm array distribute[block]
+    float A[N];
+
+    isum1 = sers1mr(C, N, RNL);
+
+/*  printf("c=%d isum1=%d\n",C[1],isum1); */
+
+    imax1 = N + 1. + RNL;
+    imin1 = -(N + 1 + RNL);
+
+    #pragma dvm region inout(A, ni1, ni2)
+    {
+    #pragma dvm parallel([i] on A[i])
+    for (i = 0; i < N; i++)
+        A[i] = RNL + i;
+
+    ni1 = N / 2 - 1;
+    A[ni1] = N + 1. + RNL;
+
+    ni2 = N / 2 + 1;
+    A[ni2] = -(N + 1 + RNL);
+
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[1])
+    {
+    imaxloct1 = A[1];
+    }
+    #pragma dvm actual(imaxloct1)
+    }
+
+    iminloct1 = imaxloct1;
+
+    isumt1 = 0.;
+
+    #pragma dvm parallel([i] on A[i]) reduction(sum(isumt1), maxloc(imaxloct1, it1), minloc(iminloct1, it2))
+    for (i = 0; i < N; i++)
+    {
+        isumt1 = isumt1 + A[i];
+        if (A[i] > imaxloct1)
+        {
+            imaxloct1 = A[i];
+            it1 = i;
+        }
+        if (A[i] < iminloct1)
+        {
+            iminloct1 = A[i];
+            it2 = i;
+        }
+    }
+
+    } /* end region */
+
+    #pragma dvm get_actual(isumt1, imaxloct1, iminloct1)
+
+    if ((isum1 == isumt1) && (imaxloct1 == imax1) && (iminloct1 == imin1) &&
+       (it1 == ni1) && (it2 == ni2))
+        ansyes(tname);
+    else
+    {
+        ansno(tname);
+//      printf("isum1=%f isumt1=%f\n",isum1,isumt1);
+//      printf("imax1=%f imaxloct1=%f it1=%d ni1=%d\n",
+//          imax1,imaxloct1,it1,ni1);
+//      printf("imin1=%f iminloct1=%f it2=%d ni2=%d\n",
+//          imin1,iminloct1,it2,ni2);
+    }
+
+    #undef N
+    #undef RNL
+}
+
+/* --------------------------------------------- */
+
+int sersum1(int *AR, int NN, int NL)
+{
+    int i, s;
+
+    for (i = 0; i < NN; i++)
+        AR[i] = NL+i;
+
+    s=0;
+
+    for (i = 0; i < NN; i++)
+        s = s + AR[i];
+
+//  printf("s=%d\n",s);
+
+    return s;
+}
+
+int sersum1m(int *AR, int NN, int NL)
+{
+    int i, ni, s;
+
+    for (i = 0; i < NN; i++)
+        AR[i] = NL + i;
+    ni = NN / 2 - 2;
+    AR[ni] = NN + 1 + NL;
+    ni= NN / 2;
+    AR[ni] = -(NN + 1 + NL);
+
+    s = 0;
+    for (i = 0; i < NN; i++)
+        s = s + AR[i];
+
+//  printf("s=%d\n",s);
+
+    return s;
+}
+
+float sers1mr(float *RAR, int NN, float RNL)
+{
+    int i, ni;
+    float s;
+
+    for (i = 0; i < NN; i++)
+        RAR[i] = RNL + i;
+    ni = NN / 2 - 1;
+    RAR[ni]=NN + 1.+ RNL;
+    ni = NN / 2 + 1;
+    RAR[ni] = -(NN + 1.+ RNL);
+
+    s = 0;
+    for (i = 0; i < NN; i++)
+        s = s + RAR[i];
+//  printf("s=%d\n",s);
+
+    return s;
+}
+
+int serprod1(int *AR, int NN, int NL)
+{
+    int i, p;
+
+    for (i = 0; i < NN; i++)
+        AR[i] = NL + i;
+
+    p = 1;
+    for (i = 0; i < NN; i++)
+       p = p * AR[i];
+
+    return p;
+}
+
+float serprodr1(float *AR, int NN, float RNL)
+{
+    int i;
+    float p;
+
+    for (i = 0; i < NN; i++)
+        AR[i] = RNL + i;
+
+    p = 1.;
+    for (i = 0; i < NN; i++)
+        p = p * AR[i];
+
+    return p;
+}
+
+int serand1(int *AR, int NN)
+{
+    int i, ni, LAND;
+
+    for (i = 0; i < NN; i++)
+        AR[i] = i % 2;
+
+    LAND = AR[1];
+
+    for (i = 0; i < NN; i++)
+        LAND = LAND && AR[i];
+
+    return LAND;
+}
+
+int seror1(int *AR, int NN)
+{
+    int i, LOR;
+
+    for (i = 0; i < NN; i++)
+        AR[i] = i % 2;
+
+    LOR = AR[1];
+
+    for (i = 0; i < NN; i++)
+        LOR = LOR || AR[i];
+
+    return LOR;
+}
+
+/* --------------------------------------------- */
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+     printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REDUCTION/red21m.cdv

@@ -0,0 +1,915 @@
+/*      TESTING OF THE REDUCTION CLAUSE .
+      REDUCTION OPERATION : SUM.PRODUCT,MAX,MIN,AND,OR,MAXLOC,MINLOC AND
+      THEIR COMBINATION ARE EXECUTED
+      FOR DISTRIBUTED ARRAY A[N][M].
+*/
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define N 8
+#define M 8
+#define NL 1000
+#define RNL 1000.
+#define PNL 1
+#define RPNL 1.
+
+static void red2101();
+static void red2102();
+static void red2103();
+static void red2104();
+static void red2105();
+static void red2106();
+static void red2107();
+static void red2108();
+static void red2109();
+static void red2111();
+static void red2112();
+static void red2113();
+static void red2114();
+
+static int sersum2(int AR[N][M], int NN, int NM, int NNL);
+static int sersum2m(int AR[N][M], int NN, int NM, int NNL);
+static float sers2mr(float RAR[N][M], int NN, int NM, float RNNL);
+static long serprod2(int AR[N][M], int NN, int NM, int NNL);
+static float serprodr2(float AR[N][M], int NN, int NM, float NNL);
+static int serand2(int AR[N][M], int NN, int NM, int NNL);
+static int seror2(int AR[N][M], int NN, int NM, int NNL);
+static int serxor2(int AR[N][M], int NN, int NM, int NNL);
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+int main(int argc, char *argv[])
+{
+    printf("===START OF red21m ========================\n");
+    red2101();
+    red2102();
+    red2103();
+    red2104();
+    red2105();
+    red2106();
+    red2107();
+    red2108();
+    red2109();
+    red2111();
+    red2112();
+    red2113();
+    red2114();
+
+    printf("=== END OF red21m ========================= \n");
+    return 0;
+}
+/* ---------------------------------------------RED2101  */
+void red2101()
+{
+    int C[N][M];
+    char tname[] = "RED2101";
+    int i, j, NN, NM, NNL, ISUM1, isum1, isumt1;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+    isum1 = sersum2(C, NN, NM, NNL);
+/*      printf("isum1=%d\n",isum1);*/
+
+    isumt1 = 0;
+    #pragma dvm actual(isumt1)
+    #pragma dvm region local(A)
+    {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(sum(isumt1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            isumt1 = isumt1 + A[i][j];
+    } /*end region*/
+
+    #pragma dvm get_actual(isumt1)
+
+    if (isum1 == isumt1)
+        ansyes(tname);
+    else
+        ansno(tname);
+//      printf("isum1=%d isumt1=%d\n",isum1,isumt1);
+}
+/* ---------------------------------------------RED2102  */
+void red2102()
+{
+    int C[N][M], CL[N][M];
+    char tname[] = "RED2102";
+    int i, j, NN, NM, NNL;
+    long iprod1, iprodt1;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = PNL;
+
+    iprod1 = serprod2(C, NN, NM, NNL);
+
+    iprodt1 = 1;
+    #pragma dvm actual(iprodt1)
+    #pragma dvm region local(A)
+    {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NNL + i + j;
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(product(iprodt1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            iprodt1 = iprodt1 * A[i][j];
+/*       printf("iprodt1=%ld\n",iprodt1);*/
+     } /*end region*/
+
+    #pragma dvm get_actual(iprodt1)
+/*       printf("iprod1=%ld iprodt1=%ld \n",
+             iprod1,iprodt1);*/
+
+    if (iprod1 == iprodt1)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/*  ---------------------------------------------RED2103*/
+void red2103()
+{
+    int C[N][M];
+    char tname[] = "RED2103";
+    int i, j, NN, NM, NNL, imax1, imaxt1, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+    ni = N / 2 - 1;
+    nj = M / 2 - 1;
+    imax1 = N + M + 1 + NL;
+
+    #pragma dvm actual(imax1, ni, nj)
+//      #pragma dvm region local(A)
+//      {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NNL + i + j;
+    A[ni][nj] = N + M + 1 + NNL;
+
+    #pragma dvm actual(A)
+    #pragma dvm region in(A)
+    {
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[0][0])
+    {
+    imaxt1=A[0][0];
+//      printf("imaxt1=%d\n",imaxt1);
+    }
+    #pragma dvm actual(imaxt1)
+    }
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(max(imaxt1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            if (A[i][j] > imaxt1) imaxt1=A[i][j];
+
+    } /*end region*/
+
+    #pragma dvm get_actual(imaxt1)
+
+    if (imax1 == imaxt1)
+        ansyes(tname);
+    else
+        ansno(tname);
+//     printf("imax1=%d imaxt1=%d\n",imax1,imaxt1);
+}
+
+ /*---------------------------------------------RED2104 */
+void red2104()
+{
+    int C[N][M];
+    char tname[] = "RED2104";
+    int i, j, NN, NM, NNL, imin1, imint1, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    ni = N / 2 +1;
+    nj = M / 2 + 1;
+    imin1 = -(N + M + 1 + NL);
+
+    #pragma dvm actual(imin1, ni, nj)
+//      #pragma dvm region local(A)
+//      {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[ni][nj] = -(N + M + 1 + NL);
+
+    #pragma dvm actual(A)
+    #pragma dvm region in(A)
+    {
+
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[0][0])
+    {
+    imint1=A[0][0];
+//      printf("imint1=%d\n",imint1);
+    }
+    #pragma dvm actual(imint1)
+    }
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(min(imint1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            if (A[i][j] < imint1) imint1=A[i][j];
+
+    } /*end region*/
+
+    #pragma dvm get_actual(imint1)
+
+    if (imin1 == imint1)
+        ansyes(tname);
+    else
+        ansno(tname);
+//      printf("imin1=%d imint1=%d\n",imin1,imint1);
+}
+/* ---------------------------------------------RED2105*/
+void red2105()
+{
+    float C[N][M];
+    char tname[] = "RED2105";
+    int i, j, NN, NM, NNL, ni, nj;
+    float imax1, imaxt1;
+
+    #pragma dvm array distribute[block][block]
+    float A[N][M];
+
+    NN = N;
+    ni = N / 2 - 1;
+    nj = M / 2 - 1;
+    imax1= N + M + 1. + RNL;
+
+    #pragma dvm actual(imax1, ni, nj)
+//      #pragma dvm region local(A)
+//      {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+    A[ni][nj] = N + M + 1. + RNL;
+
+    #pragma dvm actual(A)
+    #pragma dvm region in(A)
+    {
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[0][0])
+    {
+    imaxt1=A[0][0];
+    }
+    #pragma dvm actual(imaxt1)
+    }
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(max(imaxt1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            if (A[i][j] > imaxt1) imaxt1 = A[i][j];
+
+    } /*end region*/
+
+    #pragma dvm get_actual(imaxt1)
+    if (imax1 == imaxt1)
+        ansyes(tname);
+    else
+        ansno(tname);
+/*      printf("imax1=%f imaxt1=%f\n",imax1,imaxt1); */
+}
+/* ---------------------------------------------RED2106 */
+void red2106()
+{
+    float C[N][M], CL[N][M];
+    char tname[] = "RED2106";
+    int i, j, NN, NM, NNL;
+    float iprod1, iprodt1, RNNL;
+
+    #pragma dvm array distribute[block][block]
+    float A[N][M];
+
+    NN = N;
+    NM = M;
+    RNNL = RPNL;
+
+    iprod1 = serprodr2(C, NN, NM, RNNL);
+    iprodt1 = 1;
+
+    #pragma dvm actual(iprodt1)
+    #pragma dvm region local(A)
+    {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(product(iprodt1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            iprodt1 = iprodt1 * A[i][j];
+/*       printf("iprodt1=%ld\n",iprodt1);*/
+    } /*end region*/
+
+    #pragma dvm get_actual(iprodt1)
+/*       printf("iprod1=%ld iprodt1=%ld \n",
+             iprod1,iprodt1);
+*/
+    if (iprod1 == iprodt1)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+/* ---------------------------------------------RED2107*/
+void red2107()
+{
+    int C[N][M], CL[N][M];
+    char tname[] = "RED2107";
+    int i, j, NN, NM, NNL;
+    int land1, landt1;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    land1 = serand2(CL, NN, NM, NNL);
+
+    #pragma dvm actual(land1)
+    #pragma dvm region local(A)
+    {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j += 2)
+            A[i][j] = 1;
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 1; j < M; j += 2)
+            A[i][j] = 0;
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[0][0])
+    {
+    landt1=A[0][0];
+    }
+    #pragma dvm actual(landt1)
+    }
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(and(landt1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            landt1 = landt1 && A[i][j];
+     } /*end region*/
+
+    #pragma dvm get_actual(landt1)
+/*       printf(" land1=%d landt1=%d\n",
+             land1,landt1);*/
+
+    if (land1 == landt1)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------RED2108*/
+void red2108()
+{
+    int C[N][M], CL[N][M];
+    char tname[] = "RED2108";
+    int i, j, NN, NM, NNL;
+    int lor1, lort1;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    lor1 = seror2(CL, NN, NM, NNL);
+
+    #pragma dvm actual(lor1)
+    #pragma dvm region local(A)
+    {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j += 2)
+            A[i][j] = 1;
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 1; j < M; j += 2)
+            A[i][j] = 0;
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[0][0])
+    {
+    lort1=A[0][0];
+    }
+    #pragma dvm actual(lort1)
+    }
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(or(lort1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            lort1 = lort1 || A[i][j];
+    } /*end region*/
+
+    #pragma dvm get_actual(lort1)
+
+    if (lor1 == lort1)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------RED2109*/
+void red2109()
+{
+    int C[N][M], CL[N][M];
+    char tname[] = "RED2109";
+    int i, j, NN, NM, NNL;
+    int lxor1, lxort1;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    lxor1 = serxor2(CL, NN, NM, NNL);
+
+    #pragma dvm actual(lxor1)
+    #pragma dvm region local(A)
+    {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j += 2)
+            A[i][j] = 1;
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 1; j < M; j += 2)
+            A[i][j] = 0;
+    #pragma dvm host_section
+    {
+    lxort1 = 0;
+    #pragma dvm actual(lxort1)
+    }
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(xor(lxort1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            lxort1 = lxort1 ^ A[i][j];
+    } /*end region*/
+
+    #pragma dvm get_actual(lxort1)
+
+    if (lxor1 == lxort1)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+/* ---------------------------------------------RED2111*/
+void red2111()
+{
+    int C[N][M];
+    char tname[] = "RED2111";
+    int i, j, NN, NM, NNL, imax1, imaxt1, ni, ni1, nj, nj1;
+    int imaxloct1;
+    int coor[2];
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    ni = N / 2 - 1;
+    nj = M / 2 - 1;
+    imax1 = N + M + 1 + NL;
+
+    #pragma dvm actual(imax1,ni,nj)
+//      #pragma dvm region local(A)
+//      {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+             A[i][j] = NL + i + j;
+    A[ni][nj] = N + M + 1 + NL;
+
+    #pragma dvm actual(A)
+    #pragma dvm region in(A)
+    {
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[0][0])
+    {
+     imaxt1=A[0][0];
+    }
+    #pragma dvm actual(imaxt1)
+    }
+    imaxloct1 = imaxt1;
+    coor[0] = 0;
+    coor[1] = 0;
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(maxloc(imaxloct1, coor))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            if (A[i][j] > imaxloct1)
+            {
+                imaxloct1 = A[i][j];
+                coor[0] = i;
+                coor[1] = j;
+            }
+
+    } /*end region*/
+
+    #pragma dvm get_actual(imaxloct1, coor)
+    if ((imaxloct1 == imax1) && (coor[0] == ni) && (coor[1] == nj))
+        ansyes(tname);
+    else
+        ansno(tname);
+/*      printf("imax1=%d imaxt1=%d imaxloct1=%d coor=%d %d ni=%d\n",
+            imax1,imaxt1,imaxloct1,coor[0],coor[1],ni); */
+}
+ /*---------------------------------------------RED2112*/
+void red2112()
+{
+    int C[N][M];
+    char tname[] = "RED2112";
+    int i, j, NN, NM, NNL, imin1, imint1, ni, ni1, nj1;
+    int iminloct1;
+    int coor[2];
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+    ni1 = N /2 + 1;
+    nj1 = M / 2 +1;
+    imin1 = -(N + 1 + M + NL);
+
+    #pragma dvm actual(imin1, ni1, nj1)
+//      #pragma dvm region local(A)
+//      {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+    A[ni1][nj1] = -(N + 1 + M + NL);
+
+    #pragma dvm actual(A)
+    #pragma dvm region in(A)
+    {
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[0][0])
+    {
+     imint1 = A[0][0];
+    }
+    #pragma dvm actual(imint1)
+    }
+    iminloct1 = imint1;
+    coor[0] = 0;
+    coor[1] = 0;
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(minloc(iminloct1,coor))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            if (A[i][j] < iminloct1)
+            {
+                iminloct1 = A[i][j];
+                coor[0] = i;
+                coor[1] = j;
+            }
+    } /*end region*/
+
+    #pragma dvm get_actual(iminloct1, coor)
+
+    if ((iminloct1 == imin1) && (coor[0] == ni1) && (coor[1] == nj1))
+        ansyes(tname);
+    else
+        ansno(tname);
+/*      printf("imin1=%d imint1=%d iminloct1=%d coor=%d %d ni1=%d\n",
+            imin1,imint1,iminloct1,coor[0],coor[1],ni1);*/
+}
+
+/* ---------------------------------------------RED2113*/
+void red2113()
+{
+    int C[N][M];
+    char tname[] = "RED2113";
+    int i, j, NN, NM, NNL, ISUM1, isum1, isumt1, imax1, imaxt1, imin1, imint1, ni, nj;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+    isum1 = sersum2m(C, NN, NM, NNL);
+    imax1 = N + M + 1 + NL;
+
+    ni = N / 2 - 1;
+    nj = M / 2 - 1;
+    imin1 = -(N + M + 1 + NL);
+    isumt1 = 0;
+
+    #pragma dvm actual(imin1, imax1, isumt1, ni, nj)
+//      #pragma dvm region local(A)
+//      {
+
+    #pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+
+    A[ni][nj] = -(N + M + 1 + NL);
+    A[ni+1][nj+1] = N + M + 1 + NL;
+
+    #pragma dvm actual(A)
+    #pragma dvm region in(A)
+    {
+
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(A[0][0])
+    {
+     imaxt1 = A[0][0];
+    }
+    #pragma dvm actual(imaxt1)
+    }
+    imint1 = imaxt1;
+
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(sum(isumt1), max(imaxt1), min(imint1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+        {
+            isumt1 = isumt1 + A[i][j];
+            if (A[i][j] > imaxt1) imaxt1 = A[i][j];
+            if (A[i][j] < imint1) imint1 = A[i][j];
+        }
+    } /*end region*/
+
+    #pragma dvm get_actual(isumt1, imaxt1, imint1)
+
+    if ((isum1 == isumt1) && (imax1 == imaxt1) && (imin1 == imint1))
+        ansyes(tname);
+    else
+        ansno(tname);
+/*     printf("isum1=%d isumt1=%d\n",isum1,isumt1);
+    printf("imax1=%d imaxt1=%d\n",imax1,imaxt1);
+    printf("imin1=%d imint1=%d\n",imin1,imint1);  */
+}
+/* ---------------------------------------------RED2114*/
+void red2114()
+{
+    int C[N][M], CL[N][M];
+    char tname[] = "RED2114";
+    int i, j, NN, NM, NNL;
+    int iprod1, iprodt1;
+    int land1, landt1;
+
+    #pragma dvm array distribute[block][block]
+    int A[N][M];
+    #pragma dvm array align([i][j]with A[i][j])
+    int B[N][M];
+
+
+    NN = N;
+    NM = M;
+    NNL = NL;
+
+    iprod1 = serprod2(C, NN, NM, NNL);
+    land1 = serand2(CL, NN, NM, NNL);
+
+    #pragma dvm actual(iprod1, land1)
+    #pragma dvm region local(A), local(B)
+    {
+
+    #pragma dvm parallel([i][j] on B[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            A[i][j] = NL + i + j;
+    #pragma dvm parallel([i][j] on B[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j += 2)
+            B[i][j] = 1;
+
+    #pragma dvm parallel([i][j] on B[i][j])
+    for (i = 0; i < N; i++)
+        for (j = 1; j < M; j += 2)
+            B[i][j] = 0;
+
+    #pragma dvm host_section
+    {
+    #pragma dvm remote_access(B[0][0])
+    {
+    landt1 = B[0][0];
+    }
+    #pragma dvm actual(landt1)
+    }
+
+    iprodt1 = 1;
+    #pragma dvm parallel([i][j] on A[i][j]) reduction(product(iprodt1), and(landt1))
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+        {
+            iprodt1 = iprodt1*A[i][j];
+            landt1 = landt1 && B[i][j];
+        }
+
+    } /*end region*/
+    #pragma dvm get_actual(iprodt1,landt1)
+
+/*       printf("iprod1=%d iprodt1=%d land1=%d landt1=%d\n",
+             iprod1,iprodt1,land1,landt1); */
+
+    if ((iprod1 == iprodt1) && (land1 == landt1))
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+int sersum2(int AR[N][M], int NN, int NM, int NNL)
+{
+    int i, j, S;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            AR[i][j] = NNL + i + j;
+
+    S = 0;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            S = S + AR[i][j];
+
+/*      printf("s=%d\n",S);*/
+    return S;
+}
+int sersum2m(int AR[N][M], int NN, int NM, int NNL)
+{
+    int i, j, ni, nj, S;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            AR[i][j] = NNL + i + j;
+    ni = NN / 2 - 1;
+    nj = NM / 2 - 1;
+    AR[ni][nj] = NN + NM + 1 + NNL;
+    ni = NN / 2;
+    nj = NM / 2;
+    AR[ni][nj] = -(NN + NM + 1 + NNL);
+    S = 0;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            S = S + AR[i][j];
+/*      printf("s=%d\n",S);*/
+    return S;
+}
+float sers2mr(float RAR[N][M], int NN, int NM, float NNL)
+{
+    int i, j, ni, nj;
+    float S;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            RAR[i][j] = NNL+i+j;
+
+    ni = NN / 2 - 1;
+    nj = NM / 2 - 1;
+    RAR[ni][nj] = NN + NM + 1. + NNL;
+    ni = NN / 2 + 1;
+    nj = NM / 2 + 1;
+    RAR[ni][nj] = -(NN + NM + 1. + NNL);
+    S = 0;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            S = S + RAR[i][j];
+
+/*      printf("s=%d\n",S);*/
+    return S;
+}
+long serprod2(int AR[N][M], int NN, int NM, int NNL)
+{
+    int i, j, ni, nj;
+    long P;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+             AR[i][j] = NNL+i+j;
+/*       printf("I=%d J=%d AR=%d\n",I,J,AR[I][J]);*/
+
+    P = 1;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+             P = P * AR[i][j];
+    return P;
+}
+float serprodr2(float AR[N][M], int NN, int NM, float NNL)
+{
+    int i, j;
+    float P;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+             AR[i][j] = NNL+i+j;
+    P = 1;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            P = P * AR[i][j];
+    return P;
+}
+int serand2(int AR[N][M], int NN, int NM, int NNL)
+{
+    int i, j, LAND;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j += 2)
+            AR[i][j] = 1;
+    for (i = 0; i < NN; i++)
+        for (j = 1; j < NM; j += 2)
+            AR[i][j] = 0;
+
+    LAND = AR[0][0];
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            LAND = LAND && AR[i][j];
+
+    return LAND;
+}
+
+int seror2(int AR[N][M], int NN, int NM, int NNL)
+{
+    int i, j, LOR;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j += 2)
+            AR[i][j] = 1;
+    for (i = 0; i < NN; i++)
+        for (j = 1; j < NM; j += 2)
+            AR[i][j] = 0;
+
+    LOR = AR[0][0];
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            LOR = LOR || AR[i][j];
+
+    return LOR;
+}
+
+int serxor2(int AR[N][M], int NN, int NM, int NNL)
+{
+    int i, j, LXOR;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j += 2)
+            AR[i][j] = 1;
+    for (i = 0; i < NN; i++)
+        for (j = 1; j < NM; j += 2)
+            AR[i][j] = 0;
+
+    LXOR = 0;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            LXOR = LXOR ^ AR[i][j];
+
+    return LXOR;
+}
+
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REMOTE/rem11.cdv

@@ -0,0 +1,537 @@
+//    TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
+//    DISTRIBUTED ARRAY A(N) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
+//    ON ALL PROCESSORS.
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void rem1101();
+void rem1102();
+void rem1103();
+void rem1104();
+void rem1105();
+void rem1106();
+void rem1107();
+void rem1108();
+void rem1109();
+void rem1110();
+void rem1111();
+void rem1112();
+
+void serial1(int *ar, int n, int nl);
+void ansyes(const char *name);
+void ansno(const char *name);
+
+#define n 16
+#define nl 1000
+#define Min(x, y) (x < y) ? (x) : (y)
+
+int main(int argc, char *argv[]) {
+  printf("===START OF REM11========================\n");
+
+  // --------------------------------------------------
+  rem1101();
+
+  // --------------------------------------------------
+  rem1102();
+
+  // --------------------------------------------------
+  rem1103();
+
+  // -------------------------------------------------
+  rem1104();
+
+  // -------------------------------------------------
+  rem1105();
+
+  // -------------------------------------------------
+  rem1106();
+
+  // --------------------------------------------------
+  rem1107();
+
+  // --------------------------------------------------
+  rem1108();
+
+  // --------------------------------------------------
+  rem1109();
+
+  // -------------------------------------------------
+  rem1110();
+
+  // -------------------------------------------------
+  rem1111();
+
+  // -------------------------------------------------
+  rem1112();
+
+  // -------------------------------------------------
+  //
+  //
+  printf("=== END OF REM11 ========================= \n");
+  return 0;
+}
+
+// ---------------------------------------------REM1101
+void rem1101() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl, ib;
+
+  const char *tname = "REM1101";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+#pragma dvm get_actual(a[0])
+#pragma dvm remote_access(a[0])
+  { ib = a[0]; }
+
+  if (ib == c[0]) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1102() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl, ib;
+
+  const char *tname = "REM1102";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+#pragma dvm get_actual(a[n - 1])
+#pragma dvm remote_access(a[n - 1])
+  { ib = a[n - 1]; }
+
+  if (ib == c[n - 1]) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1103() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl, ib;
+
+  const char *tname = "REM1103";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+#pragma dvm get_actual(a[n / 2 - 1])
+#pragma dvm remote_access(a[n / 2 - 1])
+  { ib = a[n / 2 - 1]; }
+
+  if (ib == c[n / 2 - 1]) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1104() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n], d[n];
+  int nloop, i, nnl, isumc, isuma;
+
+  const char *tname = "REM1104";
+  isumc = 0;
+  isuma = 0;
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+  for (i = 1; i <= n; i++) {
+#pragma dvm get_actual(a[i - 1])
+#pragma dvm remote_access(a[i - 1])
+    { d[i - 1] = a[i - 1]; }
+    isumc = isumc + c[i - 1];
+    isuma = isuma + d[i - 1];
+  }
+
+  if (isumc == isuma) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1105() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n], d[n];
+  int nloop, i, nnl, isumc, isuma;
+
+  const char *tname = "REM1105";
+  isumc = 0;
+  isuma = 0;
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+#pragma dvm get_actual(a)
+  for (i = 1; i <= n; i++) {
+#pragma dvm remote_access(a[])
+    { d[i - 1] = a[i - 1]; }
+    isumc = isumc + c[i - 1];
+    isuma = isuma + d[i - 1];
+  }
+
+  if (isumc == isuma) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1106() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n], d[n];
+  int nloop, i, nnl, isumc, isuma;
+
+  const char *tname = "REM1106";
+  isumc = 0;
+  isuma = 0;
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+  int kk = 2;
+  int kk1 = 3;
+  for (i = 1; i <= n / kk - kk1; i++) {
+#pragma dvm get_actual(a[kk * (i - 1) + kk1])
+#pragma dvm remote_access(a[kk * (i - 1) + kk1])
+    { d[i - 1] = a[kk * (i - 1) + kk1]; }
+    isumc = isumc + c[kk * (i - 1) + kk1];
+    isuma = isuma + d[i - 1];
+  }
+
+  if (isumc == isuma) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1107() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1107";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[0])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[0];
+    }
+
+#pragma dvm parallel([i] on a[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[0]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1108() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1108";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[n - 1])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[n - 1];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[n - 1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1109() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1109";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[n / 2 - 1])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[n / 2 - 1];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[n / 2 - 1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1110() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1110";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[i - 1];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[i - 1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1111() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1111";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[i - 1])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[i - 1];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[i - 1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1112() {
+#pragma dvm array distribute[block]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1112";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+  int kk = 2;
+  int kk1 = 3;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[kk * i + (kk1 - kk)])
+    for (i = 1; i <= n / kk - kk1; i++) {
+      b[i - 1] = a[kk * i + (kk1 - kk)];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n / kk - kk1; i++) {
+      if (b[i - 1] != c[kk * (i - 1) + kk1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+#undef n
+#undef nl
+
+void serial1(int *ar, int n, int nl) {
+  int i;
+  for (i = 1; i <= n; i++) {
+    ar[i - 1] = nl + i;
+  }
+}
+
+void ansyes(const char *name) { printf("%s  -  complete\n", name); }
+
+void ansno(const char *name) { printf("%s  -  ***error\n", name); }

dvm/tools/tester/trunk/test-suite/Correctness/C/REMOTE/rem12.cdv

@@ -0,0 +1,537 @@
+//    TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
+//    DISTRIBUTED ARRAY A(N) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
+//    ON ALL PROCESSORS.
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void rem1101();
+void rem1102();
+void rem1103();
+void rem1104();
+void rem1105();
+void rem1106();
+void rem1107();
+void rem1108();
+void rem1109();
+void rem1110();
+void rem1111();
+void rem1112();
+
+void serial1(int *ar, int n, int nl);
+void ansyes(const char *name);
+void ansno(const char *name);
+
+#define n 16
+#define nl 1000
+#define Min(x, y) (x < y) ? (x) : (y)
+
+int main(int argc, char *argv[]) {
+  printf("===START OF REM11========================\n");
+
+  // --------------------------------------------------
+  rem1101();
+
+  // --------------------------------------------------
+  rem1102();
+
+  // --------------------------------------------------
+  rem1103();
+
+  // -------------------------------------------------
+  rem1104();
+
+  // -------------------------------------------------
+  rem1105();
+
+  // -------------------------------------------------
+  rem1106();
+
+  // --------------------------------------------------
+  rem1107();
+
+  // --------------------------------------------------
+  rem1108();
+
+  // --------------------------------------------------
+  rem1109();
+
+  // -------------------------------------------------
+  rem1110();
+
+  // -------------------------------------------------
+  rem1111();
+
+  // -------------------------------------------------
+  rem1112();
+
+  // -------------------------------------------------
+  //
+  //
+  printf("=== END OF REM11 ========================= \n");
+  return 0;
+}
+
+// ---------------------------------------------REM1101
+void rem1101() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl, ib;
+
+  const char *tname = "REM1101";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+#pragma dvm get_actual(a[0])
+#pragma dvm remote_access(a[0])
+  { ib = a[0]; }
+
+  if (ib == c[0]) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1102() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl, ib;
+
+  const char *tname = "REM1102";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+#pragma dvm get_actual(a[n - 1])
+#pragma dvm remote_access(a[n - 1])
+  { ib = a[n - 1]; }
+
+  if (ib == c[n - 1]) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1103() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl, ib;
+
+  const char *tname = "REM1103";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+#pragma dvm get_actual(a[n / 2 - 1])
+#pragma dvm remote_access(a[n / 2 - 1])
+  { ib = a[n / 2 - 1]; }
+
+  if (ib == c[n / 2 - 1]) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1104() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n], d[n];
+  int nloop, i, nnl, isumc, isuma;
+
+  const char *tname = "REM1104";
+  isumc = 0;
+  isuma = 0;
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+  for (i = 1; i <= n; i++) {
+#pragma dvm get_actual(a[i - 1])
+#pragma dvm remote_access(a[i - 1])
+    { d[i - 1] = a[i - 1]; }
+    isumc = isumc + c[i - 1];
+    isuma = isuma + d[i - 1];
+  }
+
+  if (isumc == isuma) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1105() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n], d[n];
+  int nloop, i, nnl, isumc, isuma;
+
+  const char *tname = "REM1105";
+  isumc = 0;
+  isuma = 0;
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+#pragma dvm get_actual(a)
+  for (i = 1; i <= n; i++) {
+#pragma dvm remote_access(a[])
+    { d[i - 1] = a[i - 1]; }
+    isumc = isumc + c[i - 1];
+    isuma = isuma + d[i - 1];
+  }
+
+  if (isumc == isuma) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1106() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n], d[n];
+  int nloop, i, nnl, isumc, isuma;
+
+  const char *tname = "REM1106";
+  isumc = 0;
+  isuma = 0;
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region out(a)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+  }
+  int kk = 2;
+  int kk1 = 3;
+  for (i = 1; i <= n / kk - kk1; i++) {
+#pragma dvm get_actual(a[kk * (i - 1) + kk1])
+#pragma dvm remote_access(a[kk * (i - 1) + kk1])
+    { d[i - 1] = a[kk * (i - 1) + kk1]; }
+    isumc = isumc + c[kk * (i - 1) + kk1];
+    isuma = isuma + d[i - 1];
+  }
+
+  if (isumc == isuma) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1107() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1107";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[0])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[0];
+    }
+
+#pragma dvm parallel([i] on a[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[0]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1108() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1108";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[n - 1])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[n - 1];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[n - 1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1109() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1109";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[n / 2 - 1])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[n / 2 - 1];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[n / 2 - 1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1110() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1110";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[i - 1];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[i - 1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1111() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1111";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[i - 1])
+    for (i = 1; i <= n; i++) {
+      b[i - 1] = a[i - 1];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n; i++) {
+      if (b[i - 1] != c[i - 1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+void rem1112() {
+#pragma dvm array distribute[*]
+  int b[n];
+#pragma dvm array align([i] with b[i])
+  int a[n];
+  int c[n];
+  int nloop, i, nnl;
+
+  const char *tname = "REM1112";
+  nnl = nl;
+  serial1(c, n, nnl);
+  nloop = nl;
+  int kk = 2;
+  int kk1 = 3;
+
+#pragma dvm region local(a, b)
+  {
+#pragma dvm parallel([i] on a[i - 1])
+    for (i = 1; i <= n; i++) {
+      a[i - 1] = nl + i;
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) remote_access(a[kk * i + (kk1 - kk)])
+    for (i = 1; i <= n / kk - kk1; i++) {
+      b[i - 1] = a[kk * i + (kk1 - kk)];
+    }
+
+#pragma dvm parallel([i] on b[i - 1]) reduction(min(nloop))
+    for (i = 1; i <= n / kk - kk1; i++) {
+      if (b[i - 1] != c[kk * (i - 1) + kk1]) {
+        nloop = Min(nloop, i);
+      }
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == nl) {
+    ansyes(tname);
+  } else {
+    ansno(tname);
+  }
+}
+
+#undef n
+#undef nl
+
+void serial1(int *ar, int n, int nl) {
+  int i;
+  for (i = 1; i <= n; i++) {
+    ar[i - 1] = nl + i;
+  }
+}
+
+void ansyes(const char *name) { printf("%s  -  complete\n", name); }
+
+void ansno(const char *name) { printf("%s  -  ***error\n", name); }

dvm/tools/tester/trunk/test-suite/Correctness/C/REMOTE/rem21.cdv

@@ -0,0 +1,943 @@
+/*  TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
+    ON ALL PROCESSORS. */
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+#define N 16
+#define M 8
+#define NL 1000
+
+static void rem2101();
+static void rem2102();
+static void rem2103();
+static void rem2104();
+static void rem2105();
+static void rem2106();
+static void rem2107();
+static void rem2108();
+static void rem2109();
+static void rem2110();
+static void rem2111();
+static void rem2112();
+static void rem2113();
+static void rem2114();
+static void rem2115();
+static void rem2116();
+static void rem2117();
+static void rem2118();
+static void rem2119();
+static void rem2120();
+static void serial2(int AR[N][M], int NN, int NM, int NNL);
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+int main(int an, char **as) {
+  printf("===START OF REM21========================\n");
+  rem2101();
+  rem2102();
+  rem2103();
+  rem2104();
+  rem2105();
+  rem2106();
+  rem2107();
+  rem2108();
+  rem2109();
+  rem2110();
+  rem2111();
+  rem2112();
+  rem2113();
+  rem2114();
+  rem2115();
+  rem2116();
+  rem2117();
+  rem2118();
+  rem2119();
+  rem2120();
+
+  printf("=== END OF REM21 ========================= \n");
+  return 0;
+}
+/* ---------------------------------------------REM2101  */
+void rem2101() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2101";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[0][0])
+#pragma dvm remote_access(A[0][0])
+  { ib = A[0][0]; }
+  if (ib == C[0][0])
+    ansyes(tname);
+  else
+    ansno(tname);
+  return;
+}
+
+/* ---------------------------------------------REM2102  */
+void rem2102() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2102";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+
+#pragma dvm get_actual(A[N - 1][M - 1])
+#pragma dvm remote_access(A[N - 1][M - 1])
+  { ib = A[N - 1][M - 1]; }
+  if (ib == C[N - 1][M - 1])
+    ansyes(tname);
+  else
+    ansno(tname);
+  return;
+}
+
+/* ---------------------------------------------REM2103  */
+void rem2103() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2103";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+
+#pragma dvm get_actual(A[0][M - 1])
+#pragma dvm remote_access(A[0][M - 1])
+  { ib = A[0][M - 1]; }
+  if (ib == C[0][M - 1])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2104  */
+void rem2104() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2104";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[N - 1][0])
+#pragma dvm remote_access(A[N - 1][0])
+  { ib = A[N - 1][0]; }
+  if (ib == C[N - 1][0])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2105  */
+void rem2105() {
+
+  int C[N][M], D[N][M];
+  int ib, isuma, isumc;
+  char tname[] = "REM2105";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int A[N][M];
+
+#pragma dvm array align([i][j] with A[i][j])
+  int B[N][M];
+  isuma = 0;
+  isumc = 0;
+  NNL = NL;
+  serial2(C, N, M, NNL);
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][])
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++) {
+#pragma dvm remote_access(A[][])
+      { D[i][j] = A[i][j]; }
+      isumc = isumc + C[i][j];
+      isuma = isuma + D[i][j];
+    }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2106  */
+void rem2106() {
+
+  int C[N][M], D[N][M];
+  int ib, isuma, isumc;
+  char tname[] = "REM2106";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int A[N][M];
+
+#pragma dvm array align([i][j] with A[i][j])
+  int B[N][M];
+  isuma = 0;
+  isumc = 0;
+  NNL = NL;
+  serial2(C, N, M, NNL);
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][0])
+  for (i = 0; i < N; i++) {
+#pragma dvm remote_access(A[][0])
+    { D[i][0] = A[i][0]; }
+    isumc = isumc + C[i][0];
+    isuma = isuma + D[i][0];
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2107  */
+void rem2107() {
+
+  int C[N][M], D[N][M];
+  int isuma, isumc;
+  char tname[] = "REM2107";
+
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int A[N][M];
+
+#pragma dvm array align([i][j] with A[i][j])
+  int B[N][M];
+  isuma = 0;
+  isumc = 0;
+  NNL = NL;
+  serial2(C, N, M, NNL);
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[0][])
+  for (j = 0; j < M; j++) {
+#pragma dvm remote_access(A[0][])
+    { D[0][j] = A[0][j]; }
+    isumc = isumc + C[0][j];
+    isuma = isuma + D[0][j];
+  }
+
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2108  */
+void rem2108() {
+
+  int C[N][M], D[N][M];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM2108";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+  isuma = 0;
+  isumc = 0;
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][M - 1])
+
+  for (i = 0; i < N; i++) {
+#pragma dvm remote_access(A[][M - 1])
+    { D[i][M - 1] = A[i][M - 1]; }
+    isumc = isumc + C[i][M - 1];
+    isuma = isuma + D[i][M - 1];
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2109  */
+void rem2109() {
+
+  int C[N][M], D[N][M];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM2109";
+
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+  isuma = 0;
+  isumc = 0;
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[N - 1][])
+  for (j = 0; j < M; j++) {
+#pragma dvm remote_access(A[N - 1][])
+    { D[N - 1][j] = A[N - 1][j]; }
+    isumc = isumc + C[N - 1][j];
+    isuma = isuma + D[N - 1][j];
+  }
+
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2110  */
+void rem2110() {
+
+  int C[N][M], D[N][M];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM2110";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+  isuma = 0;
+  isumc = 0;
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][])
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++) {
+#pragma dvm remote_access(A[i][j])
+      { D[i][j] = A[i][j]; }
+      isumc = isumc + C[i][j];
+      isuma = isuma + D[i][j];
+    }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2111  */
+void rem2111() {
+
+  int C[N][M], D[N][M];
+  int nloop, ib, isuma, isumc, kk, kk1;
+  char tname[] = "REM2111";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+  isuma = 0;
+  isumc = 0;
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][])
+
+  kk = 2;
+  kk1 = 3;
+
+  for (i = 0; i < N / (kk - kk1); i++)
+    for (j = 0; j < M / (kk - kk1); j++) {
+#pragma dvm remote_access(A[kk * i + kk1][kk * j + kk1])
+      { D[i][j] = A[kk * i + kk1][kk * j + kk1]; }
+      isumc = isumc + C[kk * i + kk1][kk * j + kk1];
+      isuma = isuma + D[i][j];
+    }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2112  */
+void rem2112() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2112";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[0][0])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[0][0];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[0][0])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2113  */
+void rem2113() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2113";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[N - 1][M - 1])
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++) {
+      B[i][j] = A[N - 1][M - 1];
+    }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++) {
+      if (B[i][j] != C[N - 1][M - 1])
+        nloop = i;
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2114  */
+void rem2114() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2114";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[0][M - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[0][M - 1];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[0][M - 1])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2115  */
+void rem2115() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2115";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[N - 1][0])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[N - 1][0];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[N - 1][0])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2116  */
+void rem2116() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2116";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[i][j];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[i][j])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2117  */
+void rem2117() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2117";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[][0])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[i][0];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[i][0])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2118  */
+void rem2118() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2118";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[0][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[0][j];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[0][j])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2119  */
+void rem2119() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2119";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[][M - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[i][M - 1];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[i][M - 1])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2120  */
+void rem2120() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2120";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[N - 1][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[N - 1][j];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[N - 1][j])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+void serial2(int AR[N][M], int NN, int NM, int NNL) {
+  int i, j;
+
+  for (i = 0; i < NN; i++)
+    for (j = 0; j < NM; j++) {
+      AR[i][j] = NNL + i + j;
+    }
+  return;
+}
+
+void ansyes(const char name[]) {
+  printf("%s  -  complete\n", name);
+  return;
+}
+void ansno(const char name[]) {
+  printf("%s  -  ***error\n", name);
+  return;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REMOTE/rem22.cdv

@@ -0,0 +1,943 @@
+/*  TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
+    ON ALL PROCESSORS. */
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+#define N 16
+#define M 8
+#define NL 1000
+
+static void rem2101();
+static void rem2102();
+static void rem2103();
+static void rem2104();
+static void rem2105();
+static void rem2106();
+static void rem2107();
+static void rem2108();
+static void rem2109();
+static void rem2110();
+static void rem2111();
+static void rem2112();
+static void rem2113();
+static void rem2114();
+static void rem2115();
+static void rem2116();
+static void rem2117();
+static void rem2118();
+static void rem2119();
+static void rem2120();
+static void serial2(int AR[N][M], int NN, int NM, int NNL);
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+int main(int an, char **as) {
+  printf("===START OF REM21========================\n");
+  rem2101();
+  rem2102();
+  rem2103();
+  rem2104();
+  rem2105();
+  rem2106();
+  rem2107();
+  rem2108();
+  rem2109();
+  rem2110();
+  rem2111();
+  rem2112();
+  rem2113();
+  rem2114();
+  rem2115();
+  rem2116();
+  rem2117();
+  rem2118();
+  rem2119();
+  rem2120();
+
+  printf("=== END OF REM21 ========================= \n");
+  return 0;
+}
+/* ---------------------------------------------REM2101  */
+void rem2101() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2101";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int B[N][M];
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[0][0])
+#pragma dvm remote_access(A[0][0])
+  { ib = A[0][0]; }
+  if (ib == C[0][0])
+    ansyes(tname);
+  else
+    ansno(tname);
+  return;
+}
+
+/* ---------------------------------------------REM2102  */
+void rem2102() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2102";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+
+#pragma dvm get_actual(A[N - 1][M - 1])
+#pragma dvm remote_access(A[N - 1][M - 1])
+  { ib = A[N - 1][M - 1]; }
+  if (ib == C[N - 1][M - 1])
+    ansyes(tname);
+  else
+    ansno(tname);
+  return;
+}
+
+/* ---------------------------------------------REM2103  */
+void rem2103() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2103";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+
+#pragma dvm get_actual(A[0][M - 1])
+#pragma dvm remote_access(A[0][M - 1])
+  { ib = A[0][M - 1]; }
+  if (ib == C[0][M - 1])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2104  */
+void rem2104() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2104";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[N - 1][0])
+#pragma dvm remote_access(A[N - 1][0])
+  { ib = A[N - 1][0]; }
+  if (ib == C[N - 1][0])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2105  */
+void rem2105() {
+
+  int C[N][M], D[N][M];
+  int ib, isuma, isumc;
+  char tname[] = "REM2105";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int A[N][M];
+
+#pragma dvm array align([i][j] with A[i][j])
+  int B[N][M];
+  isuma = 0;
+  isumc = 0;
+  NNL = NL;
+  serial2(C, N, M, NNL);
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][])
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++) {
+#pragma dvm remote_access(A[][])
+      { D[i][j] = A[i][j]; }
+      isumc = isumc + C[i][j];
+      isuma = isuma + D[i][j];
+    }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2106  */
+void rem2106() {
+
+  int C[N][M], D[N][M];
+  int ib, isuma, isumc;
+  char tname[] = "REM2106";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int A[N][M];
+
+#pragma dvm array align([i][j] with A[i][j])
+  int B[N][M];
+  isuma = 0;
+  isumc = 0;
+  NNL = NL;
+  serial2(C, N, M, NNL);
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][0])
+  for (i = 0; i < N; i++) {
+#pragma dvm remote_access(A[][0])
+    { D[i][0] = A[i][0]; }
+    isumc = isumc + C[i][0];
+    isuma = isuma + D[i][0];
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2107  */
+void rem2107() {
+
+  int C[N][M], D[N][M];
+  int isuma, isumc;
+  char tname[] = "REM2107";
+
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int A[N][M];
+
+#pragma dvm array align([i][j] with A[i][j])
+  int B[N][M];
+  isuma = 0;
+  isumc = 0;
+  NNL = NL;
+  serial2(C, N, M, NNL);
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[0][])
+  for (j = 0; j < M; j++) {
+#pragma dvm remote_access(A[0][])
+    { D[0][j] = A[0][j]; }
+    isumc = isumc + C[0][j];
+    isuma = isuma + D[0][j];
+  }
+
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2108  */
+void rem2108() {
+
+  int C[N][M], D[N][M];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM2108";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+  isuma = 0;
+  isumc = 0;
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][M - 1])
+
+  for (i = 0; i < N; i++) {
+#pragma dvm remote_access(A[][M - 1])
+    { D[i][M - 1] = A[i][M - 1]; }
+    isumc = isumc + C[i][M - 1];
+    isuma = isuma + D[i][M - 1];
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2109  */
+void rem2109() {
+
+  int C[N][M], D[N][M];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM2109";
+
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+  isuma = 0;
+  isumc = 0;
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[N - 1][])
+  for (j = 0; j < M; j++) {
+#pragma dvm remote_access(A[N - 1][])
+    { D[N - 1][j] = A[N - 1][j]; }
+    isumc = isumc + C[N - 1][j];
+    isuma = isuma + D[N - 1][j];
+  }
+
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2110  */
+void rem2110() {
+
+  int C[N][M], D[N][M];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM2110";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+  isuma = 0;
+  isumc = 0;
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][])
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++) {
+#pragma dvm remote_access(A[i][j])
+      { D[i][j] = A[i][j]; }
+      isumc = isumc + C[i][j];
+      isuma = isuma + D[i][j];
+    }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2111  */
+void rem2111() {
+
+  int C[N][M], D[N][M];
+  int nloop, ib, isuma, isumc, kk, kk1;
+  char tname[] = "REM2111";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+  isuma = 0;
+  isumc = 0;
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+  }
+#pragma dvm get_actual(A[][])
+
+  kk = 2;
+  kk1 = 3;
+
+  for (i = 0; i < N / (kk - kk1); i++)
+    for (j = 0; j < M / (kk - kk1); j++) {
+#pragma dvm remote_access(A[kk * i + kk1][kk * j + kk1])
+      { D[i][j] = A[kk * i + kk1][kk * j + kk1]; }
+      isumc = isumc + C[kk * i + kk1][kk * j + kk1];
+      isuma = isuma + D[i][j];
+    }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2112  */
+void rem2112() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2112";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[0][0])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[0][0];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[0][0])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2113  */
+void rem2113() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2113";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[N - 1][M - 1])
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++) {
+      B[i][j] = A[N - 1][M - 1];
+    }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++) {
+      if (B[i][j] != C[N - 1][M - 1])
+        nloop = i;
+    }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2114  */
+void rem2114() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2114";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[0][M - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[0][M - 1];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[0][M - 1])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2115  */
+void rem2115() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2115";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[N - 1][0])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[N - 1][0];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[N - 1][0])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2116  */
+void rem2116() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2116";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[i][j];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[i][j])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM2117  */
+void rem2117() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2117";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[][0])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[i][0];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[i][0])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2118  */
+void rem2118() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2118";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[0][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[0][j];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[0][j])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2119  */
+void rem2119() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2119";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[*][block]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[][M - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[i][M - 1];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[i][M - 1])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM2120  */
+void rem2120() {
+
+  int C[N][M];
+  int nloop, ib;
+  char tname[] = "REM2120";
+  int i, j, NN, NM, NNL;
+
+#pragma dvm array distribute[block][*]
+  int B[N][M];
+
+#pragma dvm array align([i][j] with B[i][j])
+  int A[N][M];
+
+  NN = N;
+  NM = M;
+  NNL = NL;
+  serial2(C, NN, NM, NNL);
+  nloop = NL;
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j] on A[i][j])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        A[i][j] = NL + i + j;
+      }
+
+#pragma dvm parallel([i][j] on B[i][j]) remote_access(A[N - 1][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        B[i][j] = A[N - 1][j];
+      }
+#pragma dvm parallel([i][j] on B[i][j]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        if (B[i][j] != C[N - 1][j])
+          nloop = i;
+      }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+void serial2(int AR[N][M], int NN, int NM, int NNL) {
+  int i, j;
+
+  for (i = 0; i < NN; i++)
+    for (j = 0; j < NM; j++) {
+      AR[i][j] = NNL + i + j;
+    }
+  return;
+}
+
+void ansyes(const char name[]) {
+  printf("%s  -  complete\n", name);
+  return;
+}
+void ansno(const char name[]) {
+  printf("%s  -  ***error\n", name);
+  return;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REMOTE/rem31.cdv

@@ -0,0 +1,702 @@
+/*  TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M,K) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
+    ON ALL PROCESSORS. */
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+#define N 16
+#define M 8
+#define K 8
+#define NL 1000
+
+static void rem3101();
+static void rem3102();
+static void rem3103();
+static void rem3104();
+static void rem3105();
+static void rem3106();
+static void rem3107();
+static void rem3108();
+static void rem3109();
+static void rem3110();
+static void rem3111();
+static void rem3112();
+static void rem3113();
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+static void serial3(int AR[N][M][K], int NN, int NM, int NK, int NNL);
+
+int main(int an, char **as) {
+  printf("===START OF REM31========================\n");
+  rem3101();
+  rem3102();
+  rem3103();
+  rem3104();
+  rem3105();
+  rem3106();
+  rem3107();
+  rem3108();
+  rem3109();
+  rem3110();
+  rem3111();
+  rem3112();
+  rem3113();
+
+  printf("=== END OF REM31 ========================= \n");
+  return 0;
+}
+/* ---------------------------------------------REM3101  */
+void rem3101() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3101";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[0][0][0])
+#pragma dvm remote_access(A[0][0][0])
+  { ib = A[0][0][0]; }
+  if (ib == C[0][0][0])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3102  */
+void rem3102() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3102";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[N - 1][M - 1][K - 1])
+#pragma dvm remote_access(A[N - 1][M - 1][K - 1])
+  { ib = A[N - 1][M - 1][K - 1]; }
+  if (ib == C[N - 1][M - 1][K - 1])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3103  */
+void rem3103() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM3103";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[][][])
+#pragma dvm remote_access(A[][][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          isumc = isumc + C[i][j][ii];
+          isuma = isuma + A[i][j][ii];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3104  */
+void rem3104() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM3104";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[0][][])
+#pragma dvm remote_access(A[0][][])
+  {
+    for (j = 0; j < M; j++)
+      for (ii = 0; ii < K; ii++) {
+        isumc = isumc + C[0][j][ii];
+        isuma = isuma + A[0][j][ii];
+      }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM3105  */
+void rem3105() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM3105";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[][M - 1][])
+#pragma dvm remote_access(A[][M - 1][])
+  {
+    for (i = 0; i < N; i++)
+      for (ii = 0; ii < K; ii++) {
+        isumc = isumc + C[i][M - 1][ii];
+        isuma = isuma + A[i][M - 1][ii];
+      }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3106  */
+void rem3106() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM3106";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[][][K - 1])
+#pragma dvm remote_access(A[][][K - 1])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        isumc = isumc + C[i][j][K - 1];
+        isuma = isuma + A[i][j][K - 1];
+      }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM3107  */
+void rem3107() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  int ki, ki1, kj, kj1, kii, kii1;
+  char tname[] = "REM3107";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A)
+  ki = 2;
+  ki1 = 3;
+  kj = 2;
+  kj1 = 3;
+  kii = 2;
+  kii1 = 3;
+  for (i = 0; i < N / ki - ki1; i++)
+    for (j = 0; j < M / kj - kj1; j++)
+      for (ii = 0; ii < K / kii - kii1; ii++) {
+#pragma dvm remote_access(A[ki * i + ki1][kj * j + kj1][kii * ii + kii1])
+        { isuma = isuma + A[ki * i + ki1][kj * j + kj1][kii * ii + kii1]; }
+        isumc = isumc + C[ki * i + ki1][kj * j + kj1][kii * ii + kii1];
+      }
+
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+  return;
+}
+
+/* ---------------------------------------------REM3108  */
+void rem3108() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3108";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[0][0][0])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+
+          B[i][j][ii] = A[0][0][0];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[0][0][0])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3109  */
+void rem3109() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3109";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii])                                \
+    remote_access(A[N - 1][M - 1][K - 1])
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++)
+      for (ii = 0; ii < K; ii++) {
+
+        B[i][j][ii] = A[N - 1][M - 1][K - 1];
+      }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++)
+      for (ii = 0; ii < K; ii++) {
+        if (B[i][j][ii] != C[N - 1][M - 1][K - 1])
+          nloop = i;
+      }
+  }
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM3110  */
+void rem3110() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3110";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+            B[i][j][ii] = A[i][j][ii];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[i][j][ii])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3111  */
+void rem3111() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3111";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[0][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+
+          B[i][j][ii] = A[0][j][ii];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[0][j][ii])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3112  */
+void rem3112() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3112";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[][M - 1][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          B[i][j][ii] = A[i][M - 1][ii];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[i][M - 1][ii])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3113  */
+void rem3113() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3113";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[][][K - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+
+          B[i][j][ii] = A[i][j][K - 1];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[i][j][K - 1])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+void serial3(int AR[N][M][K], int NN, int NM, int NK, int NNL) {
+  int i, j, ii;
+
+  for (i = 0; i < NN; i++)
+    for (j = 0; j < NM; j++)
+      for (ii = 0; ii < NK; ii++)
+
+      {
+        AR[i][j][ii] = NNL + i + j + ii;
+      }
+}
+
+void ansyes(const char name[]) {
+  printf("%s  -  complete\n", name);
+  return;
+}
+void ansno(const char name[]) {
+  printf("%s  -  ***error\n", name);
+  return;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REMOTE/rem32.cdv

@@ -0,0 +1,705 @@
+/*  TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M,K) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
+    ON ALL PROCESSORS. */
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+#define N 16
+#define M 8
+#define K 8
+#define NL 1000
+
+static void rem3101();
+static void rem3102();
+static void rem3103();
+static void rem3104();
+static void rem3105();
+static void rem3106();
+static void rem3107();
+static void rem3108();
+static void rem3109();
+static void rem3110();
+static void rem3111();
+static void rem3112();
+static void rem3113();
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+static void serial3(int AR[N][M][K], int NN, int NM, int NK, int NNL);
+
+int main(int an, char **as) {
+  printf("===START OF REM31========================\n");
+  rem3101();
+  rem3102();
+  rem3103();
+  rem3104();
+  rem3105();
+  rem3106();
+  rem3107();
+  rem3108();
+  rem3109();
+  rem3110();
+  rem3111();
+  rem3112();
+  rem3113();
+
+  printf("=== END OF REM31 ========================= \n");
+  return 0;
+}
+/* ---------------------------------------------REM3101  */
+void rem3101() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3101";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[*][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[1][1][1])
+#pragma dvm remote_access(A[1][1][1])
+  { ib = A[1][1][1]; }
+  if (ib == C[1][1][1])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3102  */
+void rem3102() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3102";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][*][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[N - 1][M - 1][K - 1])
+#pragma dvm remote_access(A[N - 1][M - 1][K - 1])
+  { ib = A[N - 1][M - 1][K - 1]; }
+  if (ib == C[N - 1][M - 1][K - 1])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3103  */
+void rem3103() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM3103";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][*]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[][][])
+#pragma dvm remote_access(A[][][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          isumc = isumc + C[i][j][ii];
+          isuma = isuma + A[i][j][ii];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3104  */
+void rem3104() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM3104";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[*][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[1][][])
+#pragma dvm remote_access(A[1][][])
+  {
+    for (j = 0; j < M; j++)
+      for (ii = 0; ii < K; ii++) {
+        isumc = isumc + C[1][j][ii];
+        isuma = isuma + A[1][j][ii];
+      }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM3105  */
+void rem3105() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM3105";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][*][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[][M - 1][])
+#pragma dvm remote_access(A[][M - 1][])
+  {
+    for (i = 0; i < N; i++)
+      for (ii = 0; ii < K; ii++) {
+        isumc = isumc + C[i][M - 1][ii];
+        isuma = isuma + A[i][M - 1][ii];
+      }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3106  */
+void rem3106() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM3106";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][*]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A[][][K - 1])
+#pragma dvm remote_access(A[][][K - 1])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++) {
+        isumc = isumc + C[i][j][K - 1];
+        isuma = isuma + A[i][j][K - 1];
+      }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM3107  */
+void rem3107() {
+
+  int C[N][M][K];
+  int nloop, ib, isuma, isumc;
+  int ki, ki1, kj, kj1, kii, kii1;
+  char tname[] = "REM3107";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[*][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+  isuma = 0;
+  isumc = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+  }
+#pragma dvm get_actual(A)
+  ki = 2;
+  ki1 = 3;
+  kj = 2;
+  kj1 = 3;
+  kii = 2;
+  kii1 = 3;
+  for (i = 0; i < N / ki - ki1; i++)
+    for (j = 0; j < M / kj - kj1; j++)
+      for (ii = 0; ii < K / kii - kii1; ii++) {
+#pragma dvm remote_access(A[ki * i + ki1][kj * j + kj1][kii * ii + kii1])
+        { isuma = isuma + A[ki * i + ki1][kj * j + kj1][kii * ii + kii1]; }
+        isumc = isumc + C[ki * i + ki1][kj * j + kj1][kii * ii + kii1];
+      }
+
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+  return;
+}
+
+/* ---------------------------------------------REM3108  */
+void rem3108() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3108";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][*][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[1][1][1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+
+          B[i][j][ii] = A[1][1][1];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[1][1][1])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3109  */
+void rem3109() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3109";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][*]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii])                                \
+    remote_access(A[N - 1][M - 1][K - 1])
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++)
+      for (ii = 0; ii < K; ii++) {
+
+        B[i][j][ii] = A[N - 1][M - 1][K - 1];
+      }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+  for (i = 0; i < N; i++)
+    for (j = 0; j < M; j++)
+      for (ii = 0; ii < K; ii++) {
+        if (B[i][j][ii] != C[N - 1][M - 1][K - 1])
+          nloop = i;
+      }
+  }
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM3110  */
+void rem3110() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3110";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[*][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+
+          B[i][j][ii] = A[i][j][ii];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[i][j][ii])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3111  */
+void rem3111() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3111";
+
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][*][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[1][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+
+          B[i][j][ii] = A[1][j][ii];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[1][j][ii])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3112  */
+void rem3112() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3112";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[block][block][*]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[][M - 1][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+
+          B[i][j][ii] = A[i][M - 1][ii];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[i][M - 1][ii])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM3113  */
+void rem3113() {
+
+  int C[N][M][K];
+  int nloop, ib;
+  char tname[] = "REM3113";
+  int i, j, ii, NN, NM, NK, NNL;
+
+#pragma dvm array distribute[*][block][block]
+  int B[N][M][K];
+
+#pragma dvm array align([i][j][ii] with B[i][j][ii])
+  int A[N][M][K];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NNL = NL;
+  serial3(C, NN, NM, NK, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          A[i][j][ii] = NL + i + j + ii;
+        }
+
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) remote_access(A[][][K - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+
+          B[i][j][ii] = A[i][j][K - 1];
+        }
+#pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          if (B[i][j][ii] != C[i][j][K - 1])
+            nloop = i;
+        }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+void serial3(int AR[N][M][K], int NN, int NM, int NK, int NNL) {
+  int i, j, ii;
+
+  for (i = 0; i < NN; i++)
+    for (j = 0; j < NM; j++)
+      for (ii = 0; ii < NK; ii++)
+
+      {
+        AR[i][j][ii] = NNL + i + j + ii;
+      }
+}
+
+void ansyes(const char name[]) {
+  printf("%s  -  complete\n", name);
+  return;
+}
+void ansno(const char name[]) {
+  printf("%s  -  ***error\n", name);
+  return;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REMOTE/rem41.cdv

@@ -0,0 +1,811 @@
+/*  TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M,K,L) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
+    ON ALL PROCESSORS. */
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+#define N 16
+#define M 16
+#define K 16
+#define L 16
+#define NL 1000
+
+static void rem4101();
+static void rem4102();
+static void rem4103();
+static void rem4104();
+static void rem4105();
+static void rem4106();
+static void rem4107();
+static void rem4108();
+static void rem4109();
+static void rem4110();
+static void rem4111();
+static void rem4112();
+static void rem4113();
+static void rem4114();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+static void serial4(int AR[N][M][K][L], int NN, int NM, int NK, int NLL,
+                    int NNL);
+
+int main(int an, char **as) {
+  printf("===START OF REM41========================\n");
+  rem4101();
+  rem4102();
+  rem4103();
+  rem4104();
+  rem4105();
+  rem4106();
+  rem4107();
+  rem4108();
+  rem4109();
+  rem4110();
+  rem4111();
+  rem4112();
+  rem4113();
+  rem4114();
+
+  printf("=== END OF REM41 ========================= \n");
+  return 0;
+}
+/* ---------------------------------------------REM4101  */
+void rem4101() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4101";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[1][1][1][1])
+#pragma dvm remote_access(A[1][1][1][1])
+  { ib = A[1][1][1][1]; }
+  if (ib == C[1][1][1][1])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4102  */
+void rem4102() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4102";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[N - 1][M - 1][K - 1][L - 1])
+#pragma dvm remote_access(A[N - 1][M - 1][K - 1][L - 1])
+  { ib = A[N - 1][M - 1][K - 1][L - 1]; }
+
+  if (ib == C[N - 1][M - 1][K - 1][L - 1])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM4103  */
+void rem4103() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4103";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][][][])
+#pragma dvm remote_access(A[][][][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < K; jj++) {
+            isumc = isumc + C[i][j][ii][jj];
+            isuma = isuma + A[i][j][ii][jj];
+          }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4104  */
+void rem4104() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4104";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[1][][][])
+#pragma dvm remote_access(A[1][][][])
+  {
+    for (j = 0; j < M; j++)
+      for (ii = 0; ii < K; ii++)
+        for (jj = 0; jj < K; jj++) {
+          isumc = isumc + C[1][j][ii][jj];
+          isuma = isuma + A[1][j][ii][jj];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4105  */
+void rem4105() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4105";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][M - 1][][])
+#pragma dvm remote_access(A[][M - 1][][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < K; jj++) {
+            isumc = isumc + C[i][M - 1][ii][jj];
+            isuma = isuma + A[i][M - 1][ii][jj];
+          }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4106  */
+void rem4106() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4106";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][][K - 1][])
+
+#pragma dvm remote_access(A[][][K - 1][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (jj = 0; jj < L; jj++) {
+          isumc = isumc + C[i][j][K - 1][jj];
+          isuma = isuma + A[i][j][K - 1][jj];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4107  */
+void rem4107() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4107";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][][][L - 1])
+#pragma dvm remote_access(A[][][][L - 1])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          isumc = isumc + C[i][j][ii][L - 1];
+          isuma = isuma + A[i][j][ii][L - 1];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4108  */
+void rem4108() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4108";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[1][1][1][1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[1][1][1][1];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[1][1][1][1])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4109  */
+void rem4109() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4109";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[N - 1][M - 1][K - 1][L - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[N - 1][M - 1][K - 1][L - 1];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[N - 1][M - 1][K - 1][L - 1])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4110  */
+void rem4110() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4110";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) remote_access(A[][][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][j][ii][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][j][ii][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4111  */
+void rem4111() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4111";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[1][][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[1][j][ii][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[1][j][ii][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM4112  */
+void rem4112() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4112";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[][M - 1][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][M - 1][ii][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][M - 1][ii][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4113  */
+void rem4113() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4113";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[][][K - 1][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][j][K - 1][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][j][K - 1][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4114  */
+void rem4114() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4114";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[][][][L - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][j][ii][L - 1];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][j][ii][L - 1])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+void serial4(int AR[N][M][K][L], int NN, int NM, int NK, int NLL, int NNL) {
+  int i, j, ii, jj;
+
+  for (i = 0; i < NN; i++)
+    for (j = 0; j < NM; j++)
+      for (ii = 0; ii < NK; ii++)
+        for (jj = 0; jj < NLL; jj++)
+
+        {
+          AR[i][j][ii][jj] = NNL + i + j + ii + jj;
+        }
+}
+void ansyes(const char name[]) {
+  printf("%s  -  complete\n", name);
+  return;
+}
+void ansno(const char name[]) {
+  printf("%s  -  ***error\n", name);
+  return;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REMOTE/rem42.cdv

@@ -0,0 +1,811 @@
+/*  TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M,K,L) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
+    ON ALL PROCESSORS. */
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+#define N 16
+#define M 16
+#define K 16
+#define L 16
+#define NL 1000
+
+static void rem4101();
+static void rem4102();
+static void rem4103();
+static void rem4104();
+static void rem4105();
+static void rem4106();
+static void rem4107();
+static void rem4108();
+static void rem4109();
+static void rem4110();
+static void rem4111();
+static void rem4112();
+static void rem4113();
+static void rem4114();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+static void serial4(int AR[N][M][K][L], int NN, int NM, int NK, int NLL,
+                    int NNL);
+
+int main(int an, char **as) {
+  printf("===START OF REM41========================\n");
+  rem4101();
+  rem4102();
+  rem4103();
+  rem4104();
+  rem4105();
+  rem4106();
+  rem4107();
+  rem4108();
+  rem4109();
+  rem4110();
+  rem4111();
+  rem4112();
+  rem4113();
+  rem4114();
+
+  printf("=== END OF REM41 ========================= \n");
+  return 0;
+}
+/* ---------------------------------------------REM4101  */
+void rem4101() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4101";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[0][0][0][0])
+#pragma dvm remote_access(A[0][0][0][0])
+  { ib = A[0][0][0][0]; }
+  if (ib == C[0][0][0][0])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4102  */
+void rem4102() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4102";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[N - 1][M - 1][K - 1][L - 1])
+#pragma dvm remote_access(A[N - 1][M - 1][K - 1][L - 1])
+  { ib = A[N - 1][M - 1][K - 1][L - 1]; }
+
+  if (ib == C[N - 1][M - 1][K - 1][L - 1])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM4103  */
+void rem4103() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4103";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][][][])
+#pragma dvm remote_access(A[][][][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < K; jj++) {
+            isumc = isumc + C[i][j][ii][jj];
+            isuma = isuma + A[i][j][ii][jj];
+          }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4104  */
+void rem4104() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4104";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[0][0][0][0])
+#pragma dvm remote_access(A[0][][][])
+  {
+    for (j = 0; j < M; j++)
+      for (ii = 0; ii < K; ii++)
+        for (jj = 0; jj < K; jj++) {
+          isumc = isumc + C[0][j][ii][jj];
+          isuma = isuma + A[0][j][ii][jj];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4105  */
+void rem4105() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4105";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][M - 1][][])
+#pragma dvm remote_access(A[][M - 1][][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < K; jj++) {
+            isumc = isumc + C[i][M - 1][ii][jj];
+            isuma = isuma + A[i][M - 1][ii][jj];
+          }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4106  */
+void rem4106() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4106";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][][K - 1][])
+
+#pragma dvm remote_access(A[][][K - 1][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (jj = 0; jj < L; jj++) {
+          isumc = isumc + C[i][j][K - 1][jj];
+          isuma = isuma + A[i][j][K - 1][jj];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4107  */
+void rem4107() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4107";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][][][L - 1])
+#pragma dvm remote_access(A[][][][L - 1])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          isumc = isumc + C[i][j][ii][L - 1];
+          isuma = isuma + A[i][j][ii][L - 1];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4108  */
+void rem4108() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4108";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[0][0][0][0])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[0][0][0][0];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[0][0][0][0])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4109  */
+void rem4109() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4109";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[N - 1][M - 1][K - 1][L - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[N - 1][M - 1][K - 1][L - 1];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[N - 1][M - 1][K - 1][L - 1])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4110  */
+void rem4110() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4110";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) remote_access(A[][][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][j][ii][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][j][ii][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4111  */
+void rem4111() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4111";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[0][][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[0][j][ii][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[0][j][ii][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM4112  */
+void rem4112() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4112";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[][M - 1][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][M - 1][ii][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][M - 1][ii][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4113  */
+void rem4113() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4113";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[][][K - 1][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][j][K - 1][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][j][K - 1][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4114  */
+void rem4114() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4114";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][*][*][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[][][][L - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][j][ii][L - 1];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][j][ii][L - 1])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+void serial4(int AR[N][M][K][L], int NN, int NM, int NK, int NLL, int NNL) {
+  int i, j, ii, jj;
+
+  for (i = 0; i < NN; i++)
+    for (j = 0; j < NM; j++)
+      for (ii = 0; ii < NK; ii++)
+        for (jj = 0; jj < NLL; jj++)
+
+        {
+          AR[i][j][ii][jj] = NNL + i + j + ii + jj;
+        }
+}
+void ansyes(const char name[]) {
+  printf("%s  -  complete\n", name);
+  return;
+}
+void ansno(const char name[]) {
+  printf("%s  -  ***error\n", name);
+  return;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/REMOTE/rem43.cdv

@@ -0,0 +1,811 @@
+/*  TESTING OF THE REMOTE_ACCESS DIRECTIVE AND THE REMOTE_ACCESS CLAUSE'.
+    DISTRIBUTED ARRAY A(N,M,K,L) OR ELEMENTS OF THIS ARRAY ARE REPLICATED
+    ON ALL PROCESSORS. */
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define Min(a, b) ((a) < (b) ? (a) : (b))
+#define N 16
+#define M 16
+#define K 16
+#define L 16
+#define NL 1000
+
+static void rem4101();
+static void rem4102();
+static void rem4103();
+static void rem4104();
+static void rem4105();
+static void rem4106();
+static void rem4107();
+static void rem4108();
+static void rem4109();
+static void rem4110();
+static void rem4111();
+static void rem4112();
+static void rem4113();
+static void rem4114();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+static void serial4(int AR[N][M][K][L], int NN, int NM, int NK, int NLL,
+                    int NNL);
+
+int main(int an, char **as) {
+  printf("===START OF REM41========================\n");
+  rem4101();
+  rem4102();
+  rem4103();
+  rem4104();
+  rem4105();
+  rem4106();
+  rem4107();
+  rem4108();
+  rem4109();
+  rem4110();
+  rem4111();
+  rem4112();
+  rem4113();
+  rem4114();
+
+  printf("=== END OF REM41 ========================= \n");
+  return 0;
+}
+/* ---------------------------------------------REM4101  */
+void rem4101() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4101";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[0][0][0][0])
+#pragma dvm remote_access(A[0][0][0][0])
+  { ib = A[0][0][0][0]; }
+  if (ib == C[0][0][0][0])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4102  */
+void rem4102() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4102";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][*][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[N - 1][M - 1][K - 1][L - 1])
+#pragma dvm remote_access(A[N - 1][M - 1][K - 1][L - 1])
+  { ib = A[N - 1][M - 1][K - 1][L - 1]; }
+
+  if (ib == C[N - 1][M - 1][K - 1][L - 1])
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM4103  */
+void rem4103() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4103";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][*][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][][][])
+#pragma dvm remote_access(A[][][][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < K; jj++) {
+            isumc = isumc + C[i][j][ii][jj];
+            isuma = isuma + A[i][j][ii][jj];
+          }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4104  */
+void rem4104() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4104";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[0][0][0][0])
+#pragma dvm remote_access(A[0][][][])
+  {
+    for (j = 0; j < M; j++)
+      for (ii = 0; ii < K; ii++)
+        for (jj = 0; jj < K; jj++) {
+          isumc = isumc + C[0][j][ii][jj];
+          isuma = isuma + A[0][j][ii][jj];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4105  */
+void rem4105() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4105";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][M - 1][][])
+#pragma dvm remote_access(A[][M - 1][][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < K; jj++) {
+            isumc = isumc + C[i][M - 1][ii][jj];
+            isuma = isuma + A[i][M - 1][ii][jj];
+          }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4106  */
+void rem4106() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4106";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][*][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][][K - 1][])
+
+#pragma dvm remote_access(A[][][K - 1][])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (jj = 0; jj < L; jj++) {
+          isumc = isumc + C[i][j][K - 1][jj];
+          isuma = isuma + A[i][j][K - 1][jj];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4107  */
+void rem4107() {
+
+  int C[N][M][K][L];
+  int nloop, ib, isuma, isumc;
+  char tname[] = "REM4107";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][*][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+  isumc = 0;
+  isuma = 0;
+
+#pragma dvm region out(A)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+  }
+#pragma dvm get_actual(A[][][][L - 1])
+#pragma dvm remote_access(A[][][][L - 1])
+  {
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++) {
+          isumc = isumc + C[i][j][ii][L - 1];
+          isuma = isuma + A[i][j][ii][L - 1];
+        }
+  }
+  if (isuma == isumc)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4108  */
+void rem4108() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4108";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[0][0][0][0])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[0][0][0][0];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[0][0][0][0])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4109  */
+void rem4109() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4109";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[N - 1][M - 1][K - 1][L - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[N - 1][M - 1][K - 1][L - 1];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[N - 1][M - 1][K - 1][L - 1])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4110  */
+void rem4110() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4110";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][*][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) remote_access(A[][][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][j][ii][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][j][ii][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4111  */
+void rem4111() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4111";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][*][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[0][][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[0][j][ii][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[0][j][ii][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+
+/* ---------------------------------------------REM4112  */
+void rem4112() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4112";
+
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[*][block][block][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[][M - 1][][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][M - 1][ii][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][M - 1][ii][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4113  */
+void rem4113() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4113";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][block][*]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[][][K - 1][])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][j][K - 1][jj];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][j][K - 1][jj])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+/* ---------------------------------------------REM4114  */
+void rem4114() {
+
+  int C[N][M][K][L];
+  int nloop, ib;
+  char tname[] = "REM4114";
+  int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+#pragma dvm array distribute[block][block][*][block]
+  int B[N][M][K][L];
+
+#pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj])
+  int A[N][M][K][L];
+
+  NN = N;
+  NM = M;
+  NK = K;
+  NLL = L;
+  NNL = NL;
+  serial4(C, NN, NM, NK, NLL, NNL);
+  nloop = NL;
+
+#pragma dvm region local(A, B)
+  {
+
+#pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            A[i][j][ii][jj] = NL + i + j + ii + jj;
+          }
+
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj])                        \
+    remote_access(A[][][][L - 1])
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+
+            B[i][j][ii][jj] = A[i][j][ii][L - 1];
+          }
+#pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloop))
+    for (i = 0; i < N; i++)
+      for (j = 0; j < M; j++)
+        for (ii = 0; ii < K; ii++)
+          for (jj = 0; jj < L; jj++) {
+            if (B[i][j][ii][jj] != C[i][j][ii][L - 1])
+              nloop = i;
+          }
+  }
+#pragma dvm get_actual(nloop)
+  if (nloop == NL)
+    ansyes(tname);
+  else
+    ansno(tname);
+}
+void serial4(int AR[N][M][K][L], int NN, int NM, int NK, int NLL, int NNL) {
+  int i, j, ii, jj;
+
+  for (i = 0; i < NN; i++)
+    for (j = 0; j < NM; j++)
+      for (ii = 0; ii < NK; ii++)
+        for (jj = 0; jj < NLL; jj++)
+
+        {
+          AR[i][j][ii][jj] = NNL + i + j + ii + jj;
+        }
+}
+void ansyes(const char name[]) {
+  printf("%s  -  complete\n", name);
+  return;
+}
+void ansno(const char name[]) {
+  printf("%s  -  ***error\n", name);
+  return;
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/SHADOW/sh31.cdv

@@ -0,0 +1,706 @@
+    /*    TESTING OF THE SHADOW DIRECTIVE AND THE SHADOW_RENEW CLAUSE'.
+     DISTRIBUTED ARRAY A(N,M,K) IS TO HAVE DIFFERENT SHADOW WIDTH
+     ON BOTH SIDES */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define N 60
+#define M 60
+#define K 60
+#define NL 1000
+
+static void sh3101();
+static void sh3102();
+static void sh3103();
+static void sh3104();
+static void sh3105();
+static void sh3106();
+static void sh3107();
+static void sh3108();
+static void sh3109();
+static void sh3110();
+static void sh3111();
+static void serial3(int AR[N][M][K], int NN, int NM, int NK, int NNL);
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+int main(int argc, char *argv[])
+{
+    printf("===START OF SH31========================\n");
+    sh3101();
+    sh3102();
+    sh3103();
+    sh3104();
+    sh3105();
+    sh3106();
+    sh3107();
+    sh3108();
+    sh3109();
+    sh3110();
+    sh3111();
+
+    printf("=== END OF SH31 ========================= \n");
+    return 0;
+}
+/* ---------------------------------------------SH3101  */
+void sh3101()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3101";
+    int i, j, ii, NN, NM, NK, NNL;
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+    #pragma dvm array align([i][j][ii] with B[i][j][ii])
+    int A[N][M][K];
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A (corner))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1;j++)
+            for (ii = 1; ii < K - 1; ii++)
+                B[i][j][ii] = A[i+1][j][ii]+A[i][j+1][ii]+A[i][j][ii+1]+A[i-1][j][ii]+
+                     A[i][j-1][ii]+A[i][j][ii-1]+A[i-1][j-1][ii-1]+
+                     A[i+1][j+1][ii+1]+A[i-1][j+1][ii]+A[i+1][j-1][ii]+
+                     A[i-1][j+1][ii-1]+A[i-1][j+1][ii+1]+A[i+1][j-1][ii-1]+
+                     A[i+1][j-1][ii+1];
+
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1;j++)
+            for (ii = 1; ii < K - 1; ii++)
+                if (B[i][j][ii]!=C[i+1][j][ii]+C[i][j+1][ii]+C[i][j][ii+1]+
+                      C[i-1][j][ii]+C[i][j-1][ii]+C[i][j][ii-1]+
+                      C[i-1][j-1][ii-1]+C[i+1][j+1][ii+1]+C[i-1][j+1][ii]+
+                      C[i+1][j-1][ii]+C[i-1][j+1][ii-1]+C[i-1][j+1][ii+1]+
+                      C[i+1][j-1][ii-1]+C[i+1][j-1][ii+1])
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3102  */
+void sh3102()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3102";
+    int i, j, ii, NN, NM, NK, NNL;
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+    #pragma dvm array align([i][j][ii] with B[i][j][ii]), shadow[2:2][2:2][2:2]
+    int A[N][M][K];
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A[1:2][2:2][1:2](corner))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                B[i][j][ii] = A[i-1][j-2][ii+2]+A[i-1][j+2][ii-1]+A[i-1][j+2][ii+2]+
+                     A[i+2][j+2][ii+2]+A[i+2][j+2][ii-1]+A[i+2][j-2][ii+2]+
+                     A[i+2][j-2][ii-1]+A[i-1][j-2][ii-1];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                if (B[i][j][ii]!= C[i-1][j-2][ii+2]+C[i-1][j+2][ii-1]+C[i-1][j+2][ii+2]+
+                     C[i+2][j+2][ii+2]+C[i+2][j+2][ii-1]+C[i+2][j-2][ii+2]+
+                     C[i+2][j-2][ii-1]+C[i-1][j-2][ii-1])
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3103  */
+void sh3103()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3103";
+    int i, j, ii, NN, NM, NK, NNL;
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+    #pragma dvm array align([i][j][ii] with B[i][j][ii]), shadow[2:2][2:2][2:2]
+    int A[N][M][K];
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A[0:2][2:2][0:2] (corner))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                B[i][j][ii] = A[i+2][j+2][ii+2]+A[i][j-2][ii]+
+                     A[i+2][j-2][ii]+A[i][j+2][ii]+ A[i][j+2][ii+2]+
+                     A[i+2][j-2][ii+2]+A[i+2][j+2][ii];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                if (B[i][j][ii]!= C[i+2][j+2][ii+2]+C[i][j-2][ii]+
+                     C[i+2][j-2][ii]+C[i][j+2][ii]+ C[i][j+2][ii+2]+
+                     C[i+2][j-2][ii+2]+C[i+2][j+2][ii] )
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3104  */
+void sh3104()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3104";
+    int i, j, ii, NN, NM, NK, NNL;
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+    #pragma dvm array align([i][j][ii] with B[i][j][ii]), shadow[2:2][2:2][2:2]
+    int A[N][M][K];
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A[2:2][2:0][2:0] (corner))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                B[i][j][ii] =  A[i+2][j][ii]+A[i-2][j-2][ii-2]
+                  +   A[i+2][j-2][ii-2]+A[i-2][j][ii-2]+ A[i-2][j-2][ii]+
+                     A[i-2][j][ii]+A[i+2][j-2][ii]+A[i+2][j][ii-2];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                if (B[i][j][ii]!=C[i+2][j][ii]+C[i-2][j-2][ii-2]
+                  +   C[i+2][j-2][ii-2]+C[i-2][j][ii-2]+ C[i-2][j-2][ii]+
+                     C[i-2][j][ii]+C[i+2][j-2][ii]+C[i+2][j][ii-2])
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+/*    printf ("%i,%i,%i\n",nloopi,nloopj,nloopii);*/
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3105  */
+void sh3105()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3105";
+    int i, j, ii, NN, NM, NK, NNL;
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+    #pragma dvm array align([i][j][ii] with B[i][j][ii]), shadow[0:2][2:2][0:2]
+    int A[N][M][K];
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A[0:2][2:2][0:2] (corner))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                B[i][j][ii] = A[i+2][j+2][ii+2]+A[i][j-2][ii]+
+                     A[i+2][j-2][ii]+A[i][j+2][ii]+ A[i][j+2][ii+2]+
+                     A[i+2][j-2][ii+2]+A[i+2][j+2][ii];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                if (B[i][j][ii]!= C[i+2][j+2][ii+2]+C[i][j-2][ii]+
+                     C[i+2][j-2][ii]+C[i][j+2][ii]+ C[i][j+2][ii+2]+
+                     C[i+2][j-2][ii+2]+C[i+2][j+2][ii])
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3106  */
+void sh3106()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3106";
+    int i, j, ii, NN, NM, NK, NNL;
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+    #pragma dvm array align([i][j][ii] with B[i][j][ii]), shadow[3:3][3:3][3:3]
+    int A[N][M][K];
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A (corner))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                B[i][j][ii] = A[i-3][j-3][ii+3]+A[i+3][j+3][ii-3]+A[i+3][j-3][ii+3]+
+                     A[i-3][j+3][ii+3]+A[i-3][j+3][ii-3]+A[i+3][j-3][ii-3]+
+                     A[i+3][j+3][ii+3]+A[i-3][j-3][ii-3];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                if (B[i][j][ii]!= C[i-3][j-3][ii+3]+C[i+3][j+3][ii-3]+C[i+3][j-3][ii+3]+
+                     C[i-3][j+3][ii+3]+C[i-3][j+3][ii-3]+C[i+3][j-3][ii-3]+
+                     C[i+3][j+3][ii+3]+C[i-3][j-3][ii-3])
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3107  */
+void sh3107()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3107";
+    int i, j, ii, NN, NM, NK, NNL;
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+    #pragma dvm array align([i][j][ii] with B[i][j][ii]), shadow[3:3][0:3][3:0]
+    int A[N][M][K];
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A (corner))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                B[i][j][ii] = A[i+3][j+3][ii]+A[i-3][j][ii-3]+A[i+3][j][ii-3]+
+                     A[i-3][j+3][ii-3]+A[i-3][j][ii]+A[i-3][j+3][ii]+
+                     A[i+3][j][ii]+A[i+3][j+3][ii-3];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                if (B[i][j][ii]!= C[i-3][j-3][ii+3]+C[i+3][j+3][ii-3]+C[i+3][j-3][ii+3]+
+                     C[i-3][j+3][ii+3]+C[i-3][j+3][ii-3]+C[i+3][j-3][ii-3]+
+                     C[i+3][j+3][ii+3]+C[i-3][j-3][ii-3])
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3108  */
+void sh3108()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3108";
+    int i, j, ii, NN, NM, NK, NNL;
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+    #pragma dvm array align([i][j][ii] with B[i][j][ii]), shadow[0:3][0:3][0:3]
+    int A[N][M][K];
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A[0:3][0:3][0:3] (corner))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                B[i][j][ii] = A[i+3][j+3][ii+3]+A[i+3][j][ii]+A[i][j+3][ii]+
+                     A[i][j][ii+3]+A[i][j+3][ii+3]+A[i+3][j][ii+3]+
+                     A[i+3][j+3][ii];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                if (B[i][j][ii]!=C[i+3][j+3][ii+3]+C[i+3][j][ii]+C[i][j+3][ii]+
+                     C[i][j][ii+3]+C[i][j+3][ii+3]+C[i+3][j][ii+3]+
+                     C[i+3][j+3][ii] )
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3109  */
+void sh3109()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3109";
+    int i, j, ii, NN, NM, NK, NNL;
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+    #pragma dvm array align([i][j][ii] with B[i][j][ii]), shadow[9:9][9:9][9:9]
+    int A[N][M][K];
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A[9:9][9:9][9:9] (corner))
+    for (i = 9; i < N - 9; i++)
+        for (j = 9; j < M - 9; j++)
+            for (ii = 9; ii < K - 9; ii++)
+                B[i][j][ii]=A[i+9][j+9][ii+9]+A[i-9][j-9][ii-9]+A[i+9][j-9][ii-9]+
+                      A[i-9][j+9][ii-9]+A[i-9][j-9][ii+9]+A[i-9][j+9][ii+9]+
+                      A[i+9][j-9][ii+9]+A[i+9][j+9][ii-9];
+
+
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 9; i < N - 9; i++)
+        for (j = 9; j < M - 9; j++)
+            for (ii = 9; ii < K - 9; ii++)
+                if (B[i][j][ii]!=C[i+9][j+9][ii+9]+C[i-9][j-9][ii-9]+C[i+9][j-9][ii-9]+
+                     C[i-9][j+9][ii-9]+C[i-9][j-9][ii+9]+C[i-9][j+9][ii+9]+
+                     C[i+9][j-9][ii+9]+C[i+9][j+9][ii-9])
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3110  */
+void sh3110()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3110";
+    int i, j, ii, NN, NM, NK, NNL;
+
+    #pragma dvm array distribute[block][block][block]
+    int B[N][M][K];
+
+    #pragma dvm array shadow[9:9][9:9][9:9]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    #pragma dvm realign(A[i][j][ii] with B[i][j][ii])
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A[9:9][9:9][9:9] (corner))
+    for (i = 9; i < N - 9; i++)
+        for (j = 9; j < M - 9; j++)
+            for (ii = 9; ii < K - 9; ii++)
+                B[i][j][ii]=A[i+9][j+9][ii+9]+A[i-9][j-9][ii-9]+A[i+9][j-9][ii-9]+
+                      A[i-9][j+9][ii-9]+A[i-9][j-9][ii+9]+A[i-9][j+9][ii+9]+
+                      A[i+9][j-9][ii+9]+A[i+9][j+9][ii-9];
+
+
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 9; i < N - 9; i++)
+        for (j = 9; j < M - 9; j++)
+            for (ii = 9; ii < K - 9; ii++)
+                if (B[i][j][ii]!=C[i+9][j+9][ii+9]+C[i-9][j-9][ii-9]+C[i+9][j-9][ii-9]+
+                     C[i-9][j+9][ii-9]+C[i-9][j-9][ii+9]+C[i-9][j+9][ii+9]+
+                     C[i+9][j-9][ii+9]+C[i+9][j+9][ii-9])
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+/* ---------------------------------------------SH3111  */
+void sh3111()
+{
+    int C[N][M][K];
+    int nloopi, nloopj, nloopii;
+    char tname[] = "SH3111";
+    int i, j, ii, NN, NM, NK, NNL;
+
+    #pragma dvm array
+    int B[N][M][K];
+
+    #pragma dvm array shadow[9:9][9:9][9:9]
+    int A[N][M][K];
+
+    NN = N;
+    NM = M;
+    NK = K;
+    NNL = NL;
+    serial3(C, NN, NM, NK, NNL);
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    #pragma dvm redistribute(B[block][block][block])
+    #pragma dvm realign(A[i][j][ii] with B[i][j][ii])
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii] on A[i][j][ii])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++) {
+                A[i][j][ii] = NL + i + j + ii;
+                B[i][j][ii] = 0;
+            }
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) shadow_renew(A[9:9][9:9][9:9] (corner))
+    for (i = 9; i < N - 9; i++)
+        for (j = 9; j < M - 9; j++)
+            for (ii = 9; ii < K - 9; ii++)
+                B[i][j][ii]=A[i+9][j+9][ii+9]+A[i-9][j-9][ii-9]+A[i+9][j-9][ii-9]+
+                      A[i-9][j+9][ii-9]+A[i-9][j-9][ii+9]+A[i-9][j+9][ii+9]+
+                      A[i+9][j-9][ii+9]+A[i+9][j+9][ii-9];
+
+
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii] on B[i][j][ii]) reduction(min(nloopi), min(nloopj), min(nloopii))
+    for (i = 9; i < N - 9; i++)
+        for (j = 9; j < M - 9; j++)
+            for (ii = 9; ii < K - 9; ii++)
+                if (B[i][j][ii]!=C[i+9][j+9][ii+9]+C[i-9][j-9][ii-9]+C[i+9][j-9][ii-9]+
+                     C[i-9][j+9][ii-9]+C[i-9][j-9][ii+9]+C[i-9][j+9][ii+9]+
+                     C[i+9][j-9][ii+9]+C[i+9][j+9][ii-9])
+                {
+                    if (nloopi > i) nloopi = i;
+                    if (nloopj > j) nloopj = j;
+                    if (nloopii > ii) nloopii = ii;
+                }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+}
+
+void serial3(int AR[N][M][K], int NN, int NM, int NK, int NNL)
+{
+    int i, j, ii;
+    for (i = 0; i < NN; i++)
+        for (j = 0; j < NM; j++)
+            for (ii = 0; ii < NK; ii++)
+                AR[i][j][ii] = NNL + i + j + ii;
+}
+
+void ansyes(const char name[])
+{
+    printf ("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/SHADOW/sh41.cdv

@@ -0,0 +1,923 @@
+/*    TESTING OF THE SHADOW DIRECTIVE AND THE SHADOW_RENEW CLAUSE'.
+     DISTRIBUTED ARRAY A(N,M,K,L) IS TO HAVE DIFFERENT SHADOW WIDTH
+     ON BOTH SIDES */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#define NL 1000
+
+static void sh4101();
+static void sh4102();
+static void sh4103();
+static void sh4104();
+static void sh4105();
+static void sh4106();
+static void sh4107();
+static void sh4108();
+static void sh4109();
+static void sh4110();
+static void sh4111();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+int main(int an, char **as)
+{
+    printf("===START OF SH41========================\n");
+    sh4101();
+    sh4102();
+    sh4103();
+    sh4104();
+    sh4105();
+    sh4106();
+    sh4107();
+    sh4108();
+    sh4109();
+    sh4110();
+    sh4111();
+
+    printf("=== END OF SH41 ========================= \n");
+    return 0;
+}
+/* ---------------------------------------------SH4101  */
+void sh4101()
+{
+    #define N 16
+    #define M 8
+    #define K 8
+    #define L 8
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4101";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj]), shadow[1:1][1:1][1:1][1:1]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A(corner))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    B[i][j][ii][jj] = A[i+1][j+1][ii+1][jj+1]+A[i-1][j-1][ii-1][jj-1]+
+                                   A[i+1][j-1][ii-1][jj-1]+A[i-1][j+1][ii-1][jj-1]+
+                                   A[i-1][j-1][ii+1][jj-1]+A[i-1][j-1][ii-1][jj+1]+
+                                   A[i+1][j+1][ii-1][jj-1]+A[i-1][j+1][ii+1][jj-1]+
+                                   A[i-1][j-1][ii+1][jj+1]+A[i+1][j-1][ii-1][jj+1]+
+                                   A[i+1][j-1][ii+1][jj-1]+A[i-1][j+1][ii-1][jj+1]+
+                                   A[i+1][j+1][ii+1][jj-1]+A[i-1][j+1][ii+1][jj+1]+
+                                   A[i+1][j-1][ii+1][jj+1]+A[i+1][j+1][ii-1][jj+1];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 1; i < N - 1; i++)
+        for (j = 1; j < M - 1; j++)
+            for (ii = 1; ii < K - 1; ii++)
+                for (jj = 1; jj < L - 1; jj++)
+                    if (B[i][j][ii][jj]!=
+                     C[i+1][j+1][ii+1][jj+1]+C[i-1][j-1][ii-1][jj-1]+
+                     C[i+1][j-1][ii-1][jj-1]+C[i-1][j+1][ii-1][jj-1]+
+                     C[i-1][j-1][ii+1][jj-1]+C[i-1][j-1][ii-1][jj+1]+
+                     C[i+1][j+1][ii-1][jj-1]+C[i-1][j+1][ii+1][jj-1]+
+                     C[i-1][j-1][ii+1][jj+1]+C[i+1][j-1][ii-1][jj+1]+
+                     C[i+1][j-1][ii+1][jj-1]+C[i-1][j+1][ii-1][jj+1]+
+                     C[i+1][j+1][ii+1][jj-1]+C[i-1][j+1][ii+1][jj+1]+
+                     C[i+1][j-1][ii+1][jj+1]+C[i+1][j+1][ii-1][jj+1])
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/*-----------------------------------------------------------SH4102  */
+void sh4102()
+{
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4102";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj]), shadow[2:2][2:2][2:2][2:2]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+      #pragma dvm parallel ([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A (corner))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    B[i][j][ii][jj] =
+                        A[i+2][j+2][ii+2][jj+2]+A[i-2][j-2][ii-2][jj-2]+
+                        A[i+2][j-2][ii-2][jj-2]+A[i-2][j+2][ii-2][jj-2]+
+                        A[i-2][j-2][ii+2][jj-2]+A[i-2][j-2][ii-2][jj+2]+
+                        A[i+2][j+2][ii-2][jj-2]+A[i-2][j+2][ii+2][jj-2]+
+                        A[i-2][j-2][ii+2][jj+2]+A[i+2][j-2][ii-2][jj+2]+
+                        A[i+2][j-2][ii+2][jj-2]+A[i-2][j+2][ii-2][jj+2]+
+                        A[i+2][j+2][ii+2][jj-2]+A[i-2][j+2][ii+2][jj+2]+
+                        A[i+2][j-2][ii+2][jj+2]+A[i+2][j+2][ii-2][jj+2];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    if (B[i][j][ii][jj]!=
+                       C[i+2][j+2][ii+2][jj+2]+C[i-2][j-2][ii-2][jj-2]+
+                       C[i+2][j-2][ii-2][jj-2]+C[i-2][j+2][ii-2][jj-2]+
+                       C[i-2][j-2][ii+2][jj-2]+C[i-2][j-2][ii-2][jj+2]+
+                       C[i+2][j+2][ii-2][jj-2]+C[i-2][j+2][ii+2][jj-2]+
+                       C[i-2][j-2][ii+2][jj+2]+C[i+2][j-2][ii-2][jj+2]+
+                       C[i+2][j-2][ii+2][jj-2]+C[i-2][j+2][ii-2][jj+2]+
+                       C[i+2][j+2][ii+2][jj-2]+C[i-2][j+2][ii+2][jj+2]+
+                       C[i+2][j-2][ii+2][jj+2]+C[i+2][j+2][ii-2][jj+2])
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------SH4103  */
+void sh4103()
+{
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4103";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj]), shadow[2:2][2:2][2:2][2:2]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A[2:0][2:2][2:0][2:0] (corner))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    B[i][j][ii][jj] =
+                        A[i-2][j-2][ii-2][jj-2]+A[i][j-2][ii][jj]+
+                        A[i-2][j-2][ii][jj]    +A[i][j-2][ii][jj]+
+                        A[i][j-2][ii-2][jj]    +A[i-2][j-2][ii][jj]+
+                        A[i][j-2][ii-2][jj-2]  +A[i][j-2][ii][jj-2]+
+                        A[i-2][j-2][ii-2][jj]  +A[i][j-2][ii-2][jj-2];
+    }/* end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    if (B[i][j][ii][jj]!=
+                        C[i-2][j-2][ii-2][jj-2]+C[i][j-2][ii][jj]+
+                        C[i-2][j-2][ii][jj]    +C[i][j-2][ii][jj]+
+                        C[i][j-2][ii-2][jj]    +C[i-2][j-2][ii][jj]+
+                        C[i][j-2][ii-2][jj-2]  +C[i][j-2][ii][jj-2]+
+                        C[i-2][j-2][ii-2][jj]  +C[i][j-2][ii-2][jj-2])
+
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------SH4104  */
+void sh4104()
+{
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4104";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj]), shadow[0:2][2:2][0:2][0:2]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+   #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A(corner))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    B[i][j][ii][jj] = A[i+2][j+2][ii+2][jj+2]+A[i][j-2][ii][jj]+
+                                          A[i+2][j-2][ii][jj]    +A[i][j-2][ii][jj]+
+                                          A[i][j+2][ii][jj]      +A[i][j-2][ii+2][jj]+
+                                          A[i+2][j+2][ii][jj]    +A[i][j-2][ii+2][jj+2]+
+                                          A[i][j+2][ii][jj+2]    +A[i+2][j+2][ii+2][jj]+
+                                          A[i][j+2][ii+2][jj+2]  +A[i+2][j-2][ii+2][jj+2];
+    }/*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    if (B[i][j][ii][jj]!=
+                        C[i+2][j+2][ii+2][jj+2]+C[i][j-2][ii][jj]+
+                        C[i+2][j-2][ii][jj]    +C[i][j-2][ii][jj]+
+                        C[i][j+2][ii][jj]      +C[i][j-2][ii+2][jj]+
+                        C[i+2][j+2][ii][jj]    +C[i][j-2][ii+2][jj+2]+
+                        C[i][j+2][ii][jj+2]    +C[i+2][j+2][ii+2][jj]+
+                        C[i][j+2][ii+2][jj+2]  +C[i+2][j-2][ii+2][jj+2])
+
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------SH4105  */
+void sh4105()
+{
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4105";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj]), shadow[2:2][2:0][0:2][2:2]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A[0:0][0:0][0:0][0:2] (corner))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    B[i][j][ii][jj] = A[i][j][ii][jj+2];
+    }/*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 2; i < N - 2; i++)
+        for (j = 2; j < M - 2; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    if (B[i][j][ii][jj]!=C[i][j][ii][jj+2])
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------SH4106  */
+void sh4106()
+{
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4106";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj]), shadow[3:3][3:3][3:3][3:3]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+      #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A (corner))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    B[i][j][ii][jj] = A[i+3][j+3][ii+3][jj+3]+A[i-3][j-3][ii-3][jj-3]+
+                                          A[i+3][j-3][ii-3][jj-3]+A[i-3][j+3][ii-3][jj-3]+
+                                          A[i-3][j-3][ii+3][jj-3]+A[i-3][j-3][ii-3][jj+3]+
+                                          A[i+3][j+3][ii-3][jj-3]+A[i-3][j+3][ii+3][jj-3]+
+                                          A[i-3][j-3][ii+3][jj+3]+A[i+3][j-3][ii-3][jj+3]+
+                                          A[i+3][j-3][ii+3][jj-3]+A[i-3][j+3][ii-3][jj+3]+
+                                          A[i+3][j+3][ii+3][jj-3]+A[i-3][j+3][ii+3][jj+3]+
+                                          A[i+3][j-3][ii+3][jj+3]+A[i+3][j+3][ii-3][jj+3];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    if (B[i][j][ii][jj]!=
+                            C[i+3][j+3][ii+3][jj+3]+C[i-3][j-3][ii-3][jj-3]+
+                            C[i+3][j-3][ii-3][jj-3]+C[i-3][j+3][ii-3][jj-3]+
+                            C[i-3][j-3][ii+3][jj-3]+C[i-3][j-3][ii-3][jj+3]+
+                            C[i+3][j+3][ii-3][jj-3]+C[i-3][j+3][ii+3][jj-3]+
+                            C[i-3][j-3][ii+3][jj+3]+C[i+3][j-3][ii-3][jj+3]+
+                            C[i+3][j-3][ii+3][jj-3]+C[i-3][j+3][ii-3][jj+3]+
+                            C[i+3][j+3][ii+3][jj-3]+C[i-3][j+3][ii+3][jj+3]+
+                            C[i+3][j-3][ii+3][jj+3]+C[i+3][j+3][ii-3][jj+3] )
+
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------SH4107  */
+void sh4107()
+{
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4107";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj]), shadow[0:3][3:3][0:3][0:3]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+      #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A(corner))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    B[i][j][ii][jj] =
+                        A[i+3][j+3][ii+3][jj+3]+A[i][j-3][ii][jj]+
+                        A[i+3][j-3][ii][jj]+A[i][j+3][ii][jj]+
+                        A[i][j-3][ii+3][jj]+A[i+3][j+3][ii][jj]+
+                        A[i][j-3][ii+3][jj+3]+A[i][j+3][ii][jj+3]+
+                        A[i+3][j+3][ii+3][jj]+A[i][j+3][ii+3][jj+3]+
+                        A[i+3][j-3][ii+3][jj+3];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    if (B[i][j][ii][jj]!=
+                             C[i+3][j+3][ii+3][jj+3]+C[i][j-3][ii][jj]+
+                             C[i+3][j-3][ii][jj]+       C[i][j+3][ii][jj]+
+                             C[i][j-3][ii+3][jj]+       C[i+3][j+3][ii][jj]+
+                             C[i][j-3][ii+3][jj+3]+     C[i][j+3][ii][jj+3]+
+                             C[i+3][j+3][ii+3][jj]+     C[i][j+3][ii+3][jj+3]+
+                             C[i+3][j-3][ii+3][jj+3])
+
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------SH4108  */
+void sh4108()
+{
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4108";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj]), shadow[0:3][3:3][0:3][0:3]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A[0:0][0:0][0:0][0:3] (corner))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    B[i][j][ii][jj] = A[i][j][ii][jj+3];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    if (B[i][j][ii][jj]!=C[i][j][ii][jj+3])
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------SH4109  */
+void sh4109()
+{
+    #define N 48
+    #define M 48
+    #define K 24
+    #define L 24
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4109";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array align([i][j][ii][jj] with B[i][j][ii][jj]), shadow[9:9][9:9][2:2][2:2]
+    int A[N][M][K][L];
+
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+      #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A[9:9][9:9][2:2][2:2] (corner))
+    for (i = 9; i < N - 9; i++)
+        for (j = 9; j < M - 9; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    B[i][j][ii][jj] = A[i+9][j+9][ii+2][jj+2]+A[i-9][j-9][ii-2][jj-2]+
+                                          A[i+9][j-9][ii-2][jj-2]+A[i-9][j+9][ii-2][jj-2]+
+                                          A[i-9][j-9][ii+2][jj-2]+A[i-9][j-9][ii-2][jj+2]+
+                                          A[i+9][j+9][ii-2][jj-2]+A[i-9][j+9][ii+2][jj-2]+
+                                          A[i-9][j-9][ii+2][jj+2]+A[i+9][j-9][ii-2][jj+2]+
+                                          A[i+9][j-9][ii+2][jj-2]+A[i-9][j+9][ii-2][jj+2]+
+                                          A[i+9][j+9][ii+2][jj-2]+A[i-9][j+9][ii+2][jj+2]+
+                                          A[i+9][j-9][ii+2][jj+2]+A[i+9][j+9][ii-2][jj+2];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 9; i < N - 9; i++)
+        for (j = 9; j < M - 9; j++)
+            for (ii = 2; ii < K - 2; ii++)
+                for (jj = 2; jj < L - 2; jj++)
+                    if (B[i][j][ii][jj]!=
+                            C[i+9][j+9][ii+2][jj+2]+C[i-9][j-9][ii-2][jj-2]+
+                            C[i+9][j-9][ii-2][jj-2]+C[i-9][j+9][ii-2][jj-2]+
+                            C[i-9][j-9][ii+2][jj-2]+C[i-9][j-9][ii-2][jj+2]+
+                            C[i+9][j+9][ii-2][jj-2]+C[i-9][j+9][ii+2][jj-2]+
+                            C[i-9][j-9][ii+2][jj+2]+C[i+9][j-9][ii-2][jj+2]+
+                            C[i+9][j-9][ii+2][jj-2]+C[i-9][j+9][ii-2][jj+2]+
+                            C[i+9][j+9][ii+2][jj-2]+C[i-9][j+9][ii+2][jj+2]+
+                            C[i+9][j-9][ii+2][jj+2]+C[i+9][j+9][ii-2][jj+2] )
+
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------SH4110  */
+void sh4110()
+{
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4110";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    #pragma dvm array distribute[block][block][block][block]
+    int B[N][M][K][L];
+    #pragma dvm array shadow[3:3][3:3][3:3][3:3]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+    #pragma dvm realign(A[i][j][ii][jj] with B[i][j][ii][jj])
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A (corner))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    B[i][j][ii][jj] = A[i+3][j+3][ii+3][jj+3]+A[i-3][j-3][ii-3][jj-3]+
+                                          A[i+3][j-3][ii-3][jj-3]+A[i-3][j+3][ii-3][jj-3]+
+                                          A[i-3][j-3][ii+3][jj-3]+A[i-3][j-3][ii-3][jj+3]+
+                                          A[i+3][j+3][ii-3][jj-3]+A[i-3][j+3][ii+3][jj-3]+
+                                          A[i-3][j-3][ii+3][jj+3]+A[i+3][j-3][ii-3][jj+3]+
+                                          A[i+3][j-3][ii+3][jj-3]+A[i-3][j+3][ii-3][jj+3]+
+                                          A[i+3][j+3][ii+3][jj-3]+A[i-3][j+3][ii+3][jj+3]+
+                                          A[i+3][j-3][ii+3][jj+3]+A[i+3][j+3][ii-3][jj+3];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    if (B[i][j][ii][jj]!=
+                            C[i+3][j+3][ii+3][jj+3]+C[i-3][j-3][ii-3][jj-3]+
+                            C[i+3][j-3][ii-3][jj-3]+C[i-3][j+3][ii-3][jj-3]+
+                            C[i-3][j-3][ii+3][jj-3]+C[i-3][j-3][ii-3][jj+3]+
+                            C[i+3][j+3][ii-3][jj-3]+C[i-3][j+3][ii+3][jj-3]+
+                            C[i-3][j-3][ii+3][jj+3]+C[i+3][j-3][ii-3][jj+3]+
+                            C[i+3][j-3][ii+3][jj-3]+C[i-3][j+3][ii-3][jj+3]+
+                            C[i+3][j+3][ii+3][jj-3]+C[i-3][j+3][ii+3][jj+3]+
+                            C[i+3][j-3][ii+3][jj+3]+C[i+3][j+3][ii-3][jj+3] )
+
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+/* ---------------------------------------------SH4111  */
+void sh4111()
+{
+    #define N 16
+    #define M 16
+    #define K 16
+    #define L 16
+
+    int C[N][M][K][L];
+    int nloopi, nloopj, nloopii, nloopjj;
+    char tname[] = "SH4111";
+    int i, j, ii, jj, NN, NM, NK, NLL, NNL;
+    #pragma dvm array
+    int B[N][M][K][L];
+    #pragma dvm array shadow[3:3][3:3][3:3][3:3]
+    int A[N][M][K][L];
+
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    C[i][j][ii][jj] = NL + i + j + ii + jj;
+    nloopi = NL;
+    nloopj = NL;
+    nloopii = NL;
+    nloopjj = NL;
+
+    #pragma dvm redistribute(B[block][block][block][block])
+    #pragma dvm realign(A[i][j][ii][jj] with B[i][j][ii][jj])
+
+    #pragma dvm region local(A), out(B)
+    {
+    #pragma dvm parallel([i][j][ii][jj] on A[i][j][ii][jj])
+    for (i = 0; i < N; i++)
+        for (j = 0; j < M; j++)
+            for (ii = 0; ii < K; ii++)
+                for (jj = 0; jj < L; jj++)
+                    A[i][j][ii][jj] = NL + i + j + ii + jj;
+
+     #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) shadow_renew(A (corner))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    B[i][j][ii][jj] = A[i+3][j+3][ii+3][jj+3]+A[i-3][j-3][ii-3][jj-3]+
+                                          A[i+3][j-3][ii-3][jj-3]+A[i-3][j+3][ii-3][jj-3]+
+                                          A[i-3][j-3][ii+3][jj-3]+A[i-3][j-3][ii-3][jj+3]+
+                                          A[i+3][j+3][ii-3][jj-3]+A[i-3][j+3][ii+3][jj-3]+
+                                          A[i-3][j-3][ii+3][jj+3]+A[i+3][j-3][ii-3][jj+3]+
+                                          A[i+3][j-3][ii+3][jj-3]+A[i-3][j+3][ii-3][jj+3]+
+                                          A[i+3][j+3][ii+3][jj-3]+A[i-3][j+3][ii+3][jj+3]+
+                                          A[i+3][j-3][ii+3][jj+3]+A[i+3][j+3][ii-3][jj+3];
+    } /*end region*/
+    #pragma dvm get_actual(B)
+    #pragma dvm parallel([i][j][ii][jj] on B[i][j][ii][jj]) reduction(min(nloopi), min(nloopj), min(nloopii), min(nloopjj))
+    for (i = 3; i < N - 3; i++)
+        for (j = 3; j < M - 3; j++)
+            for (ii = 3; ii < K - 3; ii++)
+                for (jj = 3; jj < L - 3; jj++)
+                    if (B[i][j][ii][jj]!=
+                            C[i+3][j+3][ii+3][jj+3]+C[i-3][j-3][ii-3][jj-3]+
+                            C[i+3][j-3][ii-3][jj-3]+C[i-3][j+3][ii-3][jj-3]+
+                            C[i-3][j-3][ii+3][jj-3]+C[i-3][j-3][ii-3][jj+3]+
+                            C[i+3][j+3][ii-3][jj-3]+C[i-3][j+3][ii+3][jj-3]+
+                            C[i-3][j-3][ii+3][jj+3]+C[i+3][j-3][ii-3][jj+3]+
+                            C[i+3][j-3][ii+3][jj-3]+C[i-3][j+3][ii-3][jj+3]+
+                            C[i+3][j+3][ii+3][jj-3]+C[i-3][j+3][ii+3][jj+3]+
+                            C[i+3][j-3][ii+3][jj+3]+C[i+3][j+3][ii-3][jj+3] )
+
+                    {
+                        if (nloopi > i) nloopi = i;
+                        if (nloopj > j) nloopj = j;
+                        if (nloopii > ii) nloopii = ii;
+                        if (nloopjj > jj) nloopjj = jj;
+                    }
+
+    if (nloopi == NL && nloopj == NL && nloopii == NL && nloopjj == NL)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef N
+    #undef M
+    #undef K
+    #undef L
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/TEMPLATE/templ1.cdv

@@ -0,0 +1,190 @@
+/*    TEMPL1
+TESTING template CLAUSE */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void templ111();
+static void templ121();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, ia, ib, ic, ja, jb, jc, k;
+
+int main(int an, char **as)
+{
+    printf("=== START OF TEMPL1 ======================\n");
+    /* TEMPLATE A1[BLOCK]   ALIGN B1[i] WITH A1[i + 4]
+                            ALIGN C1[i] WITH A1[2*i + 4] */
+    templ111();
+    /* TEMPLATE A1[BLOCK]   ALIGN B1[][i]  WITH A1[i]
+                            ALIGN C1[i][] WITH A1[2*i + 1] */
+    templ121();
+    printf("=== END OF TEMPL1 ========================\n");
+    return 0;
+}
+
+/* ---------------------------------------------TEMPL111*/
+/* TEMPLATE A1[BLOCK]   ALIGN B1[i] WITH A1[i + 4]
+                        ALIGN C1[i] WITH A1[2*i + 4] */
+void templ111()
+{
+    #define AN1 14
+    #define BN1 8
+    #define CN1 4
+    int k1i = 1, k2i = 0, li = 4;
+    int kc1i = 2, kc2i = 0, lci = 4;
+    char tname[] = "templ111 ";
+
+    #pragma dvm template[AN1] distribute[block]
+    void *A1;
+    #pragma dvm array align([i] with A1[k1i * i + li])
+    int B1[BN1];
+    #pragma dvm array align([i] with A1[kc1i * i + lci])
+    int C1[CN1];
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+        #pragma dvm parallel([i] on B1[i])
+        for (i = 0; i < BN1; i++)
+                B1[i] = i;
+
+        #pragma dvm parallel([i] on C1[i])
+        for (i = 0; i < CN1; i++)
+                C1[i] = i;
+
+        #pragma dvm parallel([i] on A1[i]) private(ib, erri, ic)
+        for (i = 0; i < AN1; i++)
+        {
+            if (((i-li) == (((i-li)/k1i) * k1i)) &&
+                    (((i-li)/k1i) >= 0) &&
+                    (((i-li)/k1i) < BN1))
+            {
+                ib = (i-li)/k1i;
+                if (B1[ib] != (ib))
+                    erri = i;
+            }
+            if (((i-lci) == (((i-lci)/kc1i) * kc1i)) &&
+                    (((i-lci)/kc1i) >= 0) &&
+                    (((i-lci)/kc1i) < CN1))
+            {
+                ic = (i-lci)/kc1i;
+                if (C1[ic] != (ic))
+                    erri = i;
+            }
+        }
+
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef BN1
+    #undef CN1
+}
+
+/* ---------------------------------------------TEMPL121*/
+/* TEMPLATE A1[BLOCK]   ALIGN B1[][i] WITH A1[i]
+                        ALIGN C1[i][] WITH A1[2*i + 1] */
+void templ121()
+{
+    int AN1 = 9;
+    int BN1 = 8;
+    int BN2 = 8;
+    int CN1 = 4;
+    int CN2 = 4;
+
+    int k1i = 1, k2i = 0, li = 0;
+    int kc1i = 2, kc2i = 0, lci = 1;
+
+    char tname[] = "templ121 ";
+
+    #pragma dvm template[AN1] distribute[block]
+    void *A1;
+    #pragma dvm array
+    int (*B2)[BN2];
+    #pragma dvm array
+    int (*C2)[CN2];
+
+    B2 = malloc(sizeof(int[BN1][BN2]));
+    C2 = malloc(sizeof(int[CN1][CN2]));
+    #pragma dvm realign(B2[][i] with A1[k1i * i + li])
+    #pragma dvm realign(C2[i][] with A1[kc1i * i + lci])
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i][j] on B2[i][j])
+    for (i = 0; i < BN1; i++)
+        for(j = 0; j < BN2; j++)
+            B2[i][j] = i*NL + j;
+
+    #pragma dvm parallel([i][j] on C2[i][j])
+    for (i = 0; i < CN1; i++)
+        for(j = 0; j < CN2; j++)
+            C2[i][j] = i*NL + j;
+
+
+    #pragma dvm parallel([i] on A1[i]) private(j, ib, jb, erri, jc, ic, k)
+    for (i = 0; i < AN1; i++)
+    {
+        for (j = 0; j < BN1; j++)
+        {
+            if (((i-li) == (((i-li)/k1i) * k1i)) &&
+                    (((i-li)/k1i) >= 0) &&
+                    (((i-li)/k1i) < BN2))
+            {
+                ib = j;
+                jb = (i-li)/k1i;
+                if (B2[ib][jb] != ib*NL + jb)
+                    erri = i*NL/10 + j;
+            }
+        }
+        for (k = 0; k < CN2; k++)
+        {
+            if (((i-lci) == (((i-lci)/kc1i) * kc1i)) &&
+                    (((i-lci)/kc1i) >= 0) &&
+                    (((i-lci)/kc1i) < CN1))
+            {
+                jc = k;
+                ic = (i-lci)/kc1i;
+                if (C2[ic][jc] != (ic*NL + jc))
+                    erri = i*NL/10 + j;
+            }
+        }
+    }
+    }
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B2);
+    free(C2);
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/TEMPLATE/templ2.cdv

@@ -0,0 +1,198 @@
+/*    TEMPL2
+TESTING template CLAUSE */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void templ211();
+static void templ221();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, ia, ib, ic, ja, jb, jc, k;
+
+int main(int an, char **as)
+{
+    printf("=== START OF TEMPL2 ======================\n");
+    /* TEMPLATE A2[BLOCK][BLOCK]   ALIGN B1[i] WITH A2[1][i]
+                            ALIGN C2[i][j] WITH A2[2*i+2][j] */
+    templ211();
+    /* TEMPLATE A2[BLOCK][BLOCK]   ALIGN B1[i][j] WITH A2[i+4][j+4]
+                            ALIGN C2[i][j] WITH A2[i+1][j+1] */
+    templ221();
+    printf("=== END OF TEMPL2 ========================\n");
+    return 0;
+}
+
+/* ---------------------------------------------TEMPL211*/
+/* TEMPLATE A2[BLOCK][BLOCK]   ALIGN B1[i] WITH A2[1][i]
+                               ALIGN C2[i][j] WITH A2[2*i+2][j] */
+void templ211()
+{
+    #define AN1 14
+    #define AN2 14
+    #define BN1 8
+    #define CN1 4
+    #define CN2 4
+
+    int k1i = 0, k2i = 0, li = 1, k1j = 1, k2j = 0, lj = 0;
+    int kc1i = 2, kc2i = 0, lci = 2, kc1j = 0, kc2j = 1, lcj = 0;
+    char tname[] = "templ211 ";
+
+    #pragma dvm template[AN1][AN2] distribute[block][block]
+    void *A2;
+    #pragma dvm array align([i] with A2[1][i])
+    int B1[BN1];
+    #pragma dvm array align([i][j] with A2[kc1i * i + lci][kc2j * j + lcj])
+    int C2[CN1][CN1];
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([i] on B1[i])
+    for (i = 0; i < BN1; i++)
+        B1[i] = i;
+
+    #pragma dvm parallel([j][i] on C2[i][j])
+    for (j = 0; j < CN2; j++)
+        for (i = 0; i < CN1; i++)
+            C2[i][j] = (i*NL+j);
+
+    #pragma dvm parallel([j][i] on A2[j][i]) private(ib, erri, ic, jc)
+    for (j = 0; j < AN2; j++)
+        for (i = 0; i < AN1; i++)
+        {
+            if (i == 0)
+            {
+                if (j < BN1)
+                {
+                    ib = j;
+                    if (B1[ib] != (ib))
+                        erri = i;
+                }
+            }
+            if (((i-lci) == (((i-lci)/kc1i) * kc1i)) &&
+                    ((j-lcj) == (((j-lcj)/kc2j) * kc2j)) &&
+                    (((i-lci)/kc1i) >= 0) &&
+                    (((j-lcj)/kc2j) >= 0) &&
+                    (((i-lci)/kc1i) < CN1) &&
+                    (((j-lcj)/kc2j) < CN2))
+            {
+                ic = (i-lci)/kc1i;
+                jc = (j-lcj)/kc2j;
+                if (C2[ic][jc] != (ic*NL+jc))
+                    erri = i;
+            }
+        }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef BN1
+    #undef CN1
+    #undef CN2
+}
+
+/* ---------------------------------------------TEMPL221*/
+/* TEMPLATE A2[BLOCK][BLOCK]   ALIGN B1[i][j] WITH A2[i+4][j+4]
+                               ALIGN C2[i][j] WITH A2[i+1][j+1] */
+void templ221()
+{
+    int AN1 = 14, AN2 = 14, CN1 = 4, CN2 = 4, BN1 = 8, BN2 = 8;
+
+    int k1i = 1, k2i = 0, li = 4, k1j = 0, k2j = 1, lj = 4;
+    int kc1i = 1, kc2i = 0, lci = 1, kc1j = 0, kc2j = 1, lcj = 1;
+
+    char tname[] = "templ221 ";
+
+    #pragma dvm template[AN1][AN2] distribute[block][block]
+    void *A2;
+    #pragma dvm array
+    int (*B2)[BN2];
+    #pragma dvm array
+    int (*C2)[CN2];
+
+    B2 = malloc(sizeof(int[BN1][BN2]));
+    C2 = malloc(sizeof(int[CN1][CN2]));
+    #pragma dvm realign(B2[i][j] with A2[k1i * i + li][k2j * j + lj])
+    #pragma dvm realign(C2[i][j] with A2[kc1i * i + lci][kc2j * j + lcj])
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([j][i] on B2[i][j])
+    for (j = 0; j < BN2; j++)
+        for (i = 0; i < BN1; i++)
+            B2[i][j] = i*NL + j;
+
+    #pragma dvm parallel([j][i] on C2[i][j])
+    for (j = 0; j < CN2; j++)
+        for (i = 0; i < CN1; i++)
+            C2[i][j] = i*NL + j;
+
+
+    #pragma dvm parallel([j][i] on A2[i][j]) private(ib, ic, erri, jb, jc)
+    for (j = 0; j < AN2; j++)
+        for (i = 0; i < AN1; i++)
+        {
+            if (((i-li) == (((i-li)/k1i) * k1i)) &&
+                    ((j-lj) == (((j-lj)/k2j) * k2j)) &&
+                    (((i-li)/k1i) >= 0) &&
+                    (((j-lj)/k2j) >= 0) &&
+                    (((i-li)/k1i) < BN1) &&
+                    (((j-lj)/k2j) < BN2))
+            {
+                ib = (i-li)/k1i;
+                jb = (j-lj)/k2j;
+                if (B2[ib][jb] != (ib*NL + jb))
+                    erri = i;
+            }
+            if (((i-lci) == (((i-lci)/kc1i) * kc1i)) &&
+                    ((j-lcj) == (((j-lcj)/kc2j) * kc2j)) &&
+                    (((i-lci)/kc1i) >= 0) &&
+                    (((j-lcj)/kc2j) >= 0) &&
+                    (((i-lci)/kc1i) < CN1) &&
+                    (((j-lcj)/kc2j) < CN2))
+            {
+                ic = (i-lci)/kc1i;
+                jc = (j-lcj)/kc2j;
+                if (C2[ic][jc] != (ic*NL+jc))
+                    erri = i;
+            }
+        }
+    }
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B2);
+    free(C2);
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/C/TEMPLATE/templ4.cdv

@@ -0,0 +1,265 @@
+/*    TEMPL4
+TESTING template CLAUSE */
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+static void templ441();
+static void templ442();
+
+static void ansyes(const char tname[]);
+static void ansno(const char tname[]);
+
+static int NL = 1000;
+static int ER = 10000;
+static int erri, i, j, ia, ib, ic, ja, jb, jc, k, m, n, mb, nb, mc, nc;
+
+int main(int an, char **as)
+{
+    printf("=== START OF TEMPL4 ======================\n");
+    /* TEMPLATE A4[BLOCK][BLOCK][BLOCK][BLOCK]
+       ALIGN B4[i][j][k][l] WITH A4[i+2][j][k][l+3]
+       ALIGN C2[i][j] WITH A4[i+2][2][3][l+3]        */
+    templ441();
+    /* TEMPLATE A4[BLOCK][BLOCK][BLOCK][BLOCK]
+       ALIGN B4[i][j][k][l] WITH A4[l][i][j][k]
+       ALIGN C4[i][j][k][l] WITH A4[i+2][j][k][l+3]  */
+    templ442();
+    printf("=== END OF TEMPL4 ========================\n");
+    return 0;
+}
+
+/* ---------------------------------------------TEMPL441*/
+/* TEMPLATE A4[BLOCK][BLOCK][BLOCK][BLOCK]
+   ALIGN B4[i][j][k][l] WITH A4[i+2][j][k][l+3]
+   ALIGN C2[i][j] WITH A4[i+2][2][3][l+3]        */
+void templ441()
+{
+    #define AN1 7
+    #define AN2 7
+    #define AN3 7
+    #define AN4 7
+    #define BN1 2
+    #define BN2 2
+    #define BN3 2
+    #define BN4 2
+    #define CN1 4
+    #define CN2 4
+
+    int k1i = 1, k2i = 0, k3i = 0, k4i = 0, li = 2;
+    int k1j = 0, k2j = 1, k3j = 0, k4j = 0, lj = 0;
+    int k1n = 0, k2n = 0, k3n = 1, k4n = 0, ln = 0;
+    int k1m = 0, k2m = 0, k3m = 0, k4m = 1, lm = 3;
+    int kc1i = 1, kc2i = 0, kc3i = 0, kc4i = 0, lci = 2;
+    int kc1j = 0, kc2j = 0, kc3j = 0, kc4j = 0, lcj = 2;
+    int kc1n = 0, kc2n = 0, kc3n = 0, kc4n = 0, lcn = 3;
+    int kc1m = 0, kc2m = 1, kc3m = 0, kc4m = 0, lcm = 3;
+    char tname[] = "templ441 ";
+
+    #pragma dvm template[AN1][AN2][AN3][AN4] distribute[block][block][block][block]
+    void *A4;
+    #pragma dvm array align([i][j][n][m] with A4[k1i*i+li][k2j*j+lj][k3n*n+ln][k4m*m+lm])
+    int B4[BN1][BN2][BN3][BN4];
+    #pragma dvm array align([i][j] with A4[kc1i*i+lci][lcj][lcn][kc2m*j+lcm])
+    int C2[CN1][CN2];
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([m][n][j][i] on B4[i][j][n][m])
+    for (m = 0; m < BN4; m++)
+        for (n = 0; n < BN3; n++)
+            for (j = 0; j < BN2; j++)
+                for (i = 0; i < BN1; i++)
+                    B4[i][j][n][m] = (i*NL/10+j*NL/100+n*NL/1000+m);
+
+    #pragma dvm parallel([j][i] on C2[i][j])
+    for (j = 0; j < CN2; j++)
+        for (i = 0; i < CN1; i++)
+            C2[i][j] = (i*NL+j);
+
+    #pragma dvm parallel([m][n][j][i] on A4[i][j][n][m]) private(ib, jb, nb, mb, ic, jc, erri)
+    for (m = 0; m < AN4; m++)
+        for (n = 0; n < AN3; n++)
+            for (j = 0; j < AN2; j++)
+                for (i = 0; i < AN1; i++)
+                {
+                    if (((i-li) == (((i-li)/k1i) * k1i)) &&
+                            ((j-lj) == (((j-lj)/k2j) *k2j)) &&
+                            ((n-ln) == (((n-ln)/k3n) * k3n)) &&
+                            ((m-lm) == (((m-lm)/k4m) *k4m)) &&
+                            (((i-li)/k1i) >= 0) &&
+                            (((j-lj)/k2j) >= 0) &&
+                            (((n-ln)/k3n) >= 0) &&
+                            (((m-lm)/k4m) >= 0) &&
+                            (((i-li)/k1i) < BN1) &&
+                            (((j-lj)/k2j) < BN2) &&
+                            (((n-ln)/k3n) < BN3) &&
+                            (((m-lm)/k4m) < BN4))
+                    {
+                        ib = (i-li)/k1i;
+                        jb = (j-lj)/k2j;
+                        nb = (n-ln)/k3n;
+                        mb = (m-lm)/k4m;
+                        if (B4[ib][jb][nb][mb] != (ib*NL/10+jb*NL/100+nb*NL/1000+mb))
+                            erri = i*NL/10 + j*NL/100+ n*NL/1000+ m;
+                    }
+                    if ((j == lcj) && (n == lcn) &&
+                            ((i-lci) == (((i-lci)/kc1i) * kc1i)) &&
+                            ((m-lcm) == (((m-lcm)/kc2m) *kc2m)) &&
+                            (((i-lci)/kc1i) >= 0) &&
+                            (((m-lcm)/kc2m) >= 0) &&
+                            (((i-lci)/kc1i) < CN1) &&
+                            (((m-lcm)/kc2m) < CN2))
+                    {
+                        ic = (i-lci)/kc1i;
+                        jc = (m-lcm)/kc2m;
+                        if (C2[ic][jc] != (ic*NL+jc))
+                            erri = i;
+                    }
+                }
+    }
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    #undef AN1
+    #undef AN2
+    #undef AN3
+    #undef AN4
+    #undef BN1
+    #undef BN2
+    #undef BN3
+    #undef BN4
+    #undef CN1
+    #undef CN2
+}
+
+/* ---------------------------------------------TEMPL442*/
+/* TEMPLATE A4[BLOCK][BLOCK][BLOCK][BLOCK]
+   ALIGN B4[i][j][k][l] WITH A4[l][i][j][k]
+   ALIGN C4[i][j][k][l] WITH A4[i+2][j][k][l+3]  */
+void templ442()
+{
+    int AN1 = 7, AN2 = 7, AN3 = 7, AN4 = 7;
+    int BN1 = 2, BN2 = 2, BN3 = 2, BN4 = 2;
+    int CN1 = 4, CN2 = 4, CN3 = 4, CN4 = 4;
+
+    int k1i = 0, k2i = 0, k3i = 0, k4i = 1, li = 0;
+    int k1j = 1, k2j = 0, k3j = 0, k4j = 0, lj = 0;
+    int k1n = 0, k2n = 1, k3n = 0, k4n = 0, ln = 0;
+    int k1m = 0, k2m = 0, k3m = 1, k4m = 0, lm = 0;
+    int kc1i = 1, kc2i = 0, kc3i = 0, kc4i = 0, lci = 2;
+    int kc1j = 0, kc2j = 1, kc3j = 0, kc4j = 0, lcj = 0;
+    int kc1n = 0, kc2n = 0, kc3n = 1, kc4n = 0, lcn = 0;
+    int kc1m = 0, kc2m = 0, kc3m = 0, kc4m = 1, lcm = 3;
+
+    char tname[] = "templ442 ";
+
+    #pragma dvm template[AN1][AN2][AN3][AN4] distribute[block][block][block][block]
+    void *A4;
+    #pragma dvm array
+    int (*B4)[BN2][BN3][BN4];
+    #pragma dvm array
+    int (*C4)[CN2][CN3][CN4];
+
+    B4 = malloc(sizeof(int[BN1][BN2][BN3][BN4]));
+    C4 = malloc(sizeof(int[CN1][CN2][CN3][CN4]));
+    #pragma dvm realign(B4[i][j][n][m] with A4[k4i*m+li][k1j*i+lj][k2n*j+ln][k3m*n+lm])
+    #pragma dvm realign(C4[i][j][n][m] with A4[kc1i*i+lci][kc2j*j+lcj][ kc3n*n+lcn][kc4m*m+lcm])
+
+    erri = ER;
+    #pragma dvm actual(erri)
+
+    #pragma dvm region
+    {
+    #pragma dvm parallel([m][n][j][i] on B4[i][j][n][m])
+    for (m = 0; m < BN4; m++)
+        for (n = 0; n < BN3; n++)
+            for (j = 0; j < BN2; j++)
+                for (i = 0; i < BN1; i++)
+                    B4[i][j][n][m] = (i*NL/10+j*NL/100+n*NL/1000+m);
+
+    #pragma dvm parallel([m][n][j][i] on C4[i][j][n][m])
+    for (m = 0; m < CN4; m++)
+        for (n = 0; n < CN3; n++)
+            for (j = 0; j < CN2; j++)
+                for (i = 0; i < CN1; i++)
+                    C4[i][j][n][m] = (i*NL/10+j*NL/100+n*NL/1000+m);
+
+    #pragma dvm parallel([m][n][j][i] on A4[i][j][n][m]) private(ib, jb, nb, mb, ic, jc, nc, mc, erri)
+    for (m = 0; m < AN4; m++)
+        for (n = 0; n < AN3; n++)
+            for (j = 0; j < AN2; j++)
+                for (i = 0; i < AN1; i++)
+                {
+                    if (((i-li) == (((i-li)/k4i) * k4i)) &&
+                            ((j-lj) == (((j-lj)/k1j) *k1j)) &&
+                            ((n-ln) == (((n-ln)/k2n) * k2n)) &&
+                            ((m-lm) == (((m-lm)/k3m) *k3m)) &&
+                            (((i-li)/k4i) >= 0) &&
+                            (((j-lj)/k1j) >= 0) &&
+                            (((n-ln)/k2n) >= 0) &&
+                            (((m-lm)/k3m) >= 0) &&
+                            (((i-li)/k4i) < BN4) &&
+                            (((j-lj)/k1j) < BN1) &&
+                            (((n-ln)/k2n) < BN2) &&
+                            (((m-lm)/k3m) < BN3))
+                    {
+                        mb = (i-li)/k4i;
+                        ib = (j-lj)/k1j;
+                        jb = (n-ln)/k2n;
+                        nb = (m-lm)/k3m;
+                        if (B4[ib][jb][nb][mb] != (ib*NL/10+jb*NL/100+nb*NL/1000+mb))
+                            erri = i*NL/10 + j*NL/100+ n*NL/1000+ m;
+                    }
+                    if (
+                            ((i-lci) == (((i-lci)/kc1i) * kc1i)) &&
+                            ((j-lcj) == (((j-lcj)/kc2j) * kc2j)) &&
+                            ((n-lcn) == (((n-lcn)/kc3n) * kc3n)) &&
+                            ((m-lcm) == (((m-lcm)/kc4m) *kc4m)) &&
+                            (((i-lci)/kc1i) >= 0) &&
+                            (((j-lcj)/kc2j) >= 0) &&
+                            (((n-lcn)/kc3n) >= 0) &&
+                            (((m-lcm)/kc2m) >= 0) &&
+                            (((i-lci)/kc1i) < CN1) &&
+                            (((j-lcj)/kc2j) < CN2) &&
+                            (((n-lcn)/kc3n) < CN3) &&
+                            (((m-lcm)/kc2m) < CN2))
+                    {
+                        ic = (i-lci)/kc1i;
+                        jc = (j-lcj)/kc2j;
+                        nc = (n-lcn)/kc3n;
+                        mc = (m-lcm)/kc4m;
+                        if (C4[ic][jc][nc][mc] != (ic*NL/10+jc*NL/100+nc*NL/1000+mc))
+                            erri = i*NL/10 + j*NL/100+ n*NL/1000+ m;
+                    }
+                }
+    }
+
+    #pragma dvm get_actual(erri)
+
+    if (erri == ER)
+        ansyes(tname);
+    else
+        ansno(tname);
+
+    free(B4);
+    free(C4);
+}
+
+void ansyes(const char name[])
+{
+    printf("%s  -  complete\n", name);
+}
+
+void ansno(const char name[])
+{
+    printf("%s  -  ***error\n", name);
+}

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/acr11.fdv

@@ -0,0 +1,591 @@
+      program ACR11
+     
+c    TESTING OF THE ACROSS CLAUSE'.       
+c    DISTRIBUTED ARRAY A(N) IS TO HAVE DIFFERENT 
+c    FLOW-DEP-LENGTH ON BOTH SIDES 
+
+      print *,'===START OF ACR11========================'
+C --------------------------------------------------
+      call acr1101
+C --------------------------------------------------
+      call acr1102
+C --------------------------------------------------
+      call acr1103
+C -------------------------------------------------
+      call acr1104
+C -------------------------------------------------
+      call acr1105
+C -------------------------------------------------
+      call acr1106
+C --------------------------------------------------
+      call acr1107
+C --------------------------------------------------
+      call acr1108
+C --------------------------------------------------
+      call acr1109
+C -------------------------------------------------
+      call acr1110
+C -------------------------------------------------
+
+C
+      print *,'=== END OF ACR11 ========================= '    
+      end
+C ---------------------------------------------ACR1101
+      subroutine ACR1101   
+      integer,parameter :: N = 8, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop                      
+!dvm$ distribute A(BLOCK)    
+
+      tname='ACR1101'
+      allocate (A(N), C(N))
+      nloop=NL
+      
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      
+      do i=2,N-1
+         C(i) = C(i-1)+C(i+1)
+      enddo
+!dvm$ actual (nloop, C)
+!dvm$ region
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo
+
+!dvm$ parallel (i) on A(i),across(A(1:1)),stage(iloop)
+      do i=2,N-1
+         A(i) = A(i-1)+A(i+1)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-1
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A,C)
+      
+      end
+C ---------------------------------------------ACR1102     
+      subroutine ACR1102
+      integer,parameter :: N = 16, NL=1000
+
+      character*7 tname 
+      integer,allocatable::  A(:),C(:)
+      integer nloop 
+                      
+!dvm$ distribute A(BLOCK)    
+
+      tname='ACR1102'
+      allocate (A(N), C(N))
+      nloop=NL
+
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=1,N-1
+         C(i) = C(i)+C(i+1)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo                                                
+               
+!dvm$ parallel (i) on A(i),across(A(0:1)),stage(iloop)
+      do i=1,N-1
+         A(i) = A(i)+A(i+1)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-1
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif
+          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+     
+      end
+C -----------------------------------------ACR1103      
+      subroutine acr1103
+      integer,parameter :: N = 16, NL=1000
+
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                     
+!dvm$ distribute A(BLOCK)    
+
+      tname='ACR1103'
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2      
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=2,N
+         C(i) = C(i)+ C(i-1)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo                                                
+               
+
+!dvm$ parallel (i) on A(i),across(A(1:0)),stage(iloop)
+      do i=2,N
+         A(i) =A(i)+ A(i-1)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-1
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+     
+      end
+      
+
+  
+ 
+C -------------------------------------------ACR1104   
+         
+      subroutine ACR1104
+      integer,parameter :: N = 16, NL=1000
+
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                    
+!dvm$ distribute A(BLOCK)    
+!dvm$ shadow A(2:2)
+  
+      tname='ACR1104'
+      allocate (A(N), C(N))
+      nloop=NL
+	  
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=3,N-2
+         C(i) = C(i-1)+C(i+1)+C(i+2)+C(i-2)
+      enddo
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo                                                
+
+!dvm$ parallel (i) on A(i),across(A(2:2)),stage(iloop)
+      do i=3,N-2
+         A(i) = A(i-1)+A(i+1)+A(i+2)+A(i-2)
+      enddo
+         
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=3,N-2
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+       if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+      
+      end      
+C -------------------------------------------ACR1105   
+         
+      subroutine ACR1105
+      integer,parameter :: N = 16, NL=1000
+
+      character*7 tname 
+      integer,allocatable::  A(:),C(:)
+      integer nloop 
+                    
+!dvm$ distribute A(BLOCK)   
+!dvm$ shadow A(2:2)
+
+      tname='ACR1105'      
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=2,N-2
+         C(i) = C(i+1)+C(i+2)
+      enddo
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo                                                
+               
+!dvm$ parallel (i) on A(i),across(A(0:2)),stage(iloop)
+      do i=2,N-2
+         A(i) = A(i+1)+A(i+2)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-2
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+      call ansyes(tname)
+    
+       else
+      call ansno(tname)
+      endif
+      deallocate (A, C)
+  
+      end   
+      
+C -------------------------------------------ACR1106   
+         
+      subroutine ACR1106
+      integer,parameter :: N = 16, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop                
+!dvm$ distribute A(BLOCK)     
+!dvm$ shadow A(2:2)
+
+      tname='ACR1106'      
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=3,N
+         C(i) = C(i-1)+C(i-2)
+      enddo
+
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo                                                
+               
+
+!dvm$ parallel (i) on A(i),across(A(2:0)),stage(iloop)
+      do i=3,N
+         A(i) = A(i-1)+A(i-2)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=3,N
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif               
+      deallocate (A, C)
+      end   
+
+C -------------------------------------------ACR1107   
+         
+      subroutine acr1107
+      integer,parameter :: N = 16, NL=1000
+
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                     
+!dvm$ distribute A(BLOCK)     
+!dvm$ shadow A(3:3)
+
+      tname='ACR1107'      
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=4,N-3
+         C(i) = C(i-1)+C(i+1)+C(i+2)+C(i-2)+C(i-3)+C(i+3)
+      enddo
+
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo                                                
+               
+!dvm$ parallel (i) on A(i),across(A(3:3)),stage(iloop)
+      do i=4,N-3
+         A(i) = A(i-1)+A(i+1)+A(i+2)+A(i-2)+A(i-3)+A(i+3)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=4,N-3
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+         
+      end
+C -------------------------------------------ACR1108  
+         
+      subroutine acr1108
+      integer,parameter :: N = 24, NL=1000
+
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                    
+!dvm$ distribute A(BLOCK)     
+!dvm$ shadow A(3:3)
+
+      tname='ACR1108'
+      allocate (A(N), C(N))
+      nloop=NL
+
+      do iloop=0,2	  
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=2,N-3
+         C(i) = C(i+1)+C(i+2)+C(i+3)
+      enddo
+
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo                                                
+               
+
+!dvm$ parallel (i) on A(i),across(A(0:3)),stage(iloop)
+      do i=2,N-3
+         A(i) = A(i+1)+A(i+2)+A(i+3)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-3
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+       
+      end
+C -------------------------------------------ACR1109   
+         
+      subroutine acr1109
+      integer,parameter :: N = 24, NL=1000
+
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                    
+!dvm$ distribute A(BLOCK)     
+!dvm$ shadow A(3:3)
+
+      tname='ACR1109'
+      allocate (A(N), C(N))
+	  nloop=NL
+
+      do iloop=0,2	  
+      NNL=NL
+      call serial1(C,N,NNL)
+
+      do i=4,N
+         C(i) = C(i-1)+C(i-2)+C(i-3)
+      enddo
+
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo                                                
+   
+!dvm$ parallel (i) on A(i),across(A(3:0)),stage(iloop)
+      do i=4,N
+         A(i) = A(i-1)+A(i-2)+A(i-3)
+      
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=4,N
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop) 
+      enddo
+       
+       if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+        
+      end 
+
+C --------------------------------------------acr1110  
+         
+      subroutine acr1110
+      integer,parameter :: N = 60, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                     
+!dvm$ distribute A(BLOCK)     
+!dvm$ shadow A(11:11)
+
+      tname='ACR1110'      
+      allocate (A(N), C(N))
+      nloop=NL
+      
+      do iloop=0,2	  
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=12,N-11
+         C(i) = C(i-9)+C(i+9)+C(i+10)+C(i-10)+C(i-11)+C(i+11)
+      enddo
+
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo                                                
+               
+
+!dvm$ parallel (i) on A(i),across(A(11:11)),stage(iloop)
+      do i=12,N-11
+         A(i) = A(i-9)+A(i+9)+A(i+10)+A(i-10)+A(i-11)+A(i+11)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=12,N-11
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+       if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+    
+      end
+C -----------------------------------------------         
+      subroutine serial1(AR,N,NL)
+      integer:: AR(N)
+      integer NL 
+      do i=1,N
+        AR(i) = NL+i
+      enddo
+                   
+      end 
+
+      subroutine ansyes(name)
+      character*7 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*7 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/acr12.fdv

@@ -0,0 +1,587 @@
+      program ACR12
+     
+c    TESTING OF THE ACROSS CLAUSE'.       
+c    DISTRIBUTED ARRAY A(N) IS TO HAVE DIFFERENT 
+c    FLOW-DEP-LENGTH ON BOTH SIDES 
+
+      print *,'===START OF ACR12========================'
+C --------------------------------------------------
+      call acr1201
+C --------------------------------------------------
+      call acr1202
+C --------------------------------------------------
+      call acr1203
+C -------------------------------------------------
+      call acr1204
+C -------------------------------------------------
+      call acr1205
+C -------------------------------------------------
+      call acr1206
+C --------------------------------------------------
+      call acr1207
+C --------------------------------------------------
+      call acr1208
+C --------------------------------------------------
+      call acr1209
+C -------------------------------------------------
+      call acr1210
+C -------------------------------------------------
+
+C
+      print *,'=== END OF ACR12 ========================= '    
+      end
+C ---------------------------------------------ACR1201
+      subroutine acr1201
+     
+      integer, parameter :: N = 8, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                      
+!dvm$ distribute A(*)    
+
+      tname='ACR1201'
+      allocate (A(N), C(N))
+      nloop=NL
+      
+      do iloop=0,2	 
+      NNL=NL    
+      call serial1(C,N,NNL)
+      
+      do i=2,N-1
+         C(i) = C(i-1)+C(i+1)
+      enddo
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo
+               
+
+!dvm$ parallel (i) on A(i),across(A(1:1)),stage(iloop)
+      do i=2,N-1
+         A(i) = A(i-1)+A(i+1)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-1
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+      
+      end
+C ---------------------------------------------ACR1202     
+      subroutine acr1202
+      integer, parameter :: N = 16, NL=1000
+     
+      character*7 tname 
+      integer,allocatable:: A(:), C(:)
+      integer nloop 
+                      
+!dvm$ distribute A(*)    
+
+      tname='ACR1202'
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=1,N-1
+         C(i) = C(i)+C(i+1)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo               
+
+!dvm$ parallel (i) on A(i),across(A(0:1)),stage(iloop)
+      do i=1,N-1
+         A(i) = A(i)+A(i+1)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-1
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+      
+      end
+C -----------------------------------------ACR1203      
+      subroutine acr1203
+      integer, parameter :: N = 16, NL=1000
+     
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                     
+!dvm$ distribute A(*)    
+
+      tname='ACR1203'
+      allocate (A(N), C(N))
+      nloop=NL
+  
+      do iloop=0,2  
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=2,N
+         C(i) =C(i)+ C(i-1)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo               
+
+!dvm$ parallel (i) on A(i),across(A(1:0)),stage(iloop)
+      do i=2,N
+         A(i) =A(i)+ A(i-1)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-1
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)     
+
+      end
+      
+C -------------------------------------------ACR1204   
+         
+      subroutine acr1204
+      integer, parameter :: N = 16, NL=1000 
+      character*7 tname 
+      integer,allocatable:: A(:), C(:)
+      integer nloop 
+                    
+!dvm$ distribute A(*)    
+!dvm$ shadow A(2:2)
+  
+      tname='ACR1204'
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2
+      NNL=NL
+      call serial1(C,N,NNL)
+      do i=3,N-2
+         C(i) = C(i-1)+C(i+1)+C(i+2)+C(i-2)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo
+               
+!dvm$ parallel (i) on A(i),across(A(2:2)),stage(iloop)
+      do i=3,N-2
+         A(i) = A(i-1)+A(i+1)+A(i+2)+A(i-2)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=3,N-2
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)       
+      
+      end      
+C -------------------------------------------ACR1205   
+         
+      subroutine acr1205
+      integer, parameter :: N = 16, NL=1000
+     
+      character*7 tname 
+      integer,allocatable:: A(:),C(:)
+      integer nloop 
+                    
+!dvm$ distribute A(*)   
+!dvm$ shadow A(2:2)
+
+      tname='ACR1205'      
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=2,N-2
+         C(i) = C(i+1)+C(i+2)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo
+               
+!dvm$ parallel (i) on A(i),across(A(0:2)),stage(iloop)
+      do i=2,N-2
+         A(i) = A(i+1)+A(i+2)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-2
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+        call ansyes(tname)    
+      else
+        call ansno(tname)
+      endif
+      deallocate (A, C)
+  
+      end   
+      
+C -------------------------------------------ACR1206   
+         
+      subroutine acr1206
+      integer, parameter :: N = 16, NL=1000
+     
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop                
+!dvm$ distribute A(*)     
+!dvm$ shadow A(2:2)
+
+      tname='ACR1206'      
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=3,N
+         C(i) = C(i-1)+C(i-2)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo
+               
+!dvm$ parallel (i) on A(i),across(A(2:0)),stage(iloop)
+      do i=3,N
+         A(i) = A(i-1)+A(i-2)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=3,N
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)         
+      end   
+
+C -------------------------------------------ACR1207   
+         
+      subroutine acr1207
+      integer, parameter :: N = 16, NL=1000
+     
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                     
+!dvm$ distribute A(*)     
+!dvm$ shadow A(3:3)
+
+      tname='ACR1207'      
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+       do i=4,N-3
+         C(i) = C(i-1)+C(i+1)+C(i+2)+C(i-2)+C(i-3)+C(i+3)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo
+               
+!dvm$ parallel (i) on A(i),across(A(3:3)),stage(iloop)
+      do i=4,N-3
+         A(i) = A(i-1)+A(i+1)+A(i+2)+A(i-2)+A(i-3)+A(i+3)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=4,N-3
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+         
+      end
+C -------------------------------------------ACR1208  
+         
+      subroutine acr1208
+      integer, parameter :: N = 24, NL=1000
+     
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                    
+!dvm$ distribute A(*)     
+!dvm$ shadow A(3:3)
+
+      tname='ACR1208'
+      allocate (A(N), C(N))
+ 	  nloop=NL
+      
+      do iloop=0,2   
+      NNL=NL    
+      call serial1(C,N,NNL)
+       do i=2,N-3
+         C(i) = C(i+1)+C(i+2)+C(i+3)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo
+               
+!dvm$ parallel (i) on A(i),across(A(0:3)),stage(iloop)
+      do i=2,N-3
+         A(i) = A(i+1)+A(i+2)+A(i+3)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=2,N-3
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+       if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+       
+      end
+C -------------------------------------------ACR1209   
+         
+      subroutine acr1209
+      integer, parameter :: N = 24, NL=1000
+
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                    
+!dvm$ distribute A(*)     
+!dvm$ shadow A(3:3)
+
+      tname='ACR1209'
+      allocate (A(N), C(N))
+	  nloop=NL
+      
+      do iloop=0,2	  
+      NNL=NL
+      call serial1(C,N,NNL)
+
+      do i=4,N
+         C(i) = C(i-1)+C(i-2)+C(i-3)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo
+   
+!dvm$ parallel (i) on A(i),across(A(3:0)),stage(iloop)
+      do i=4,N
+         A(i) = A(i-1)+A(i-2)+A(i-3)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=4,N
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif
+        enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+      
+       if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+        
+      end 
+
+C --------------------------------------------ACR1210  
+         
+      subroutine acr1210
+      integer, parameter :: N = 50, NL=1000
+    
+      character*7 tname 
+      integer,allocatable::  A(:), C(:)
+      integer nloop 
+                     
+!dvm$ distribute A(*)     
+!dvm$ shadow A(11:11)
+
+      tname='ACR1210'      
+      allocate (A(N), C(N))
+ 	  nloop=NL
+      
+      do iloop=0,2
+      NNL=NL    
+      call serial1(C,N,NNL)
+      do i=12,N-11
+         C(i) = C(i-9)+C(i+9)+C(i+10)+C(i-10)+C(i-11)+C(i+11)
+      enddo
+      
+!dvm$ actual (nloop, C)
+!dvm$ region
+
+!dvm$ parallel (i) on A(i)
+      do i=1,N
+        A(i) = NL+i
+      enddo
+
+!dvm$ parallel (i) on A(i),across(A(11:11)),stage(iloop)
+      do i=12,N-11
+         A(i) = A(i-9)+A(i+9)+A(i+10)+A(i-10)+A(i-11)+A(i+11)
+      enddo
+  
+!dvm$ parallel (i) on A(i), reduction( min( nloop ) )
+      do i=12,N-11
+          if (A(i).ne. C(i)) then
+          nloop=min(nloop,i)
+          endif          
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloop)
+      enddo
+	  
+       if (nloop .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+     
+      end
+C -----------------------------------------------         
+      subroutine serial1(AR,N,NL)
+      integer AR(N)
+      integer NL 
+      do i=1,N
+        AR(i) = NL+i
+      enddo                   
+      end 
+
+      subroutine ansyes(name)
+      character*7 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*7 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/acr21.fdv

@@ -0,0 +1,977 @@
+      program ACR21
+     
+c    TESTING OF THE ACROSS CLAUSE.       
+c    DISTRIBUTED ARRAY A(N,M) IS TO HAVE DIFFERENT 
+c    FLOW-DEP-LENGTH ON BOTH SIDES 
+
+      print *,'===START OF ACR21========================'
+C --------------------------------------------------
+      call acr2101
+C --------------------------------------------------
+      call acr2102
+C --------------------------------------------------
+      call acr2103
+C -------------------------------------------------
+      call acr2104
+C -------------------------------------------------
+      call acr2105
+C -------------------------------------------------
+      call acr2106
+C --------------------------------------------------
+      call acr2107
+C --------------------------------------------------
+      call acr2108
+C --------------------------------------------------
+      call acr2109
+C -------------------------------------------------
+      call acr2110
+C -------------------------------------------------
+      call acr2111
+C -------------------------------------------------
+      call acr2112
+C -------------------------------------------------
+      call acr2113
+C -------------------------------------------------
+      call acr2114
+C -------------------------------------------------
+      call acr2115
+C -------------------------------------------------
+      print *,'=== END OF ACR21 ========================= '    
+      end
+C ---------------------------------------------ACR2101
+      subroutine ACR2101
+     
+      integer,parameter :: N = 16, M=16, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:,:), C(:,:)
+      integer nloopi,nloopj
+                      
+!dvm$ distribute A(BLOCK,BLOCK)    
+
+      tname='ACR2101'
+      allocate (A(N,M), C(N,M))
+      
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      nloopi=NL
+      nloopj=NL
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i+1,j)+C(i,j+1)+C(i-1,j)+C(i,j-1)
+        enddo
+      enddo
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(1:1,1:1)),stage(iloop)
+      do j=2,M-1
+         do i=2,N-1
+            A(i,j) = A(i+1,j)+A(i,j+1)+A(i-1,j)+A(i,j-1)
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=2,M-1
+       do i=2,N-1
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi,nloopj)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+      
+      end
+C ---------------------------------------------ACR2102     
+      subroutine ACR2102
+      integer,parameter :: N = 16,M=16, NL=1000
+
+      character*7 tname 
+      integer,allocatable::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+                      
+!dvm$ distribute A(BLOCK,BLOCK)    
+
+      tname='ACR2102'
+      allocate (A(N,M), C(N,M))
+      
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i+1,j)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual(nloopi,nloopj)
+!dvm$ region
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+!dvm$ parallel (j,i) on A(i,j),across(A(0:1,0:0)),stage(iloop)
+      do j=2,M-1
+       do i=2,N-1
+         A(i,j) = A(i+1,j)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+       do j=2,M-1
+        do i=2,N-1
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+       enddo
+	       
+      if (nloopi .eq.NL) then
+        call ansyes(tname)
+      else
+        call ansno(tname)
+      endif                                                 
+      deallocate (A, C)
+               
+      end
+
+C -----------------------------------------ACR2103      
+      subroutine acr2103
+      integer,parameter :: N = 16,M=16, NL=1000
+     
+      character*7 tname 
+      integer,allocatable::  A(:,:), C(:,:)
+
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+
+      tname='ACR2103'
+      allocate (A(N,M), C(N,M))  
+	        
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      nloopi=NL
+      nloopj=NL
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i-1,j)+C(i,j+1)
+        enddo
+      enddo
+!dvm$ actual (nloopi,nloopj,C(:,:))
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(1:0,0:1)),stage(iloop)
+      do j=2,M-1
+       do i=2,N-1
+         A(i,j) = A(i-1,j)+A(i,j+1)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+       do j=2,M-1
+        do i=2,N-1
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif
+      deallocate (A, C)
+    
+      end
+
+C ------------------------------------------ACR2104   
+      subroutine acr2104
+      integer,parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow A(1:1,0:1)
+      tname='ACR2104'
+      allocate (A(N,M), C(N,M))  
+	        
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      nloopi=NL
+      nloopj=NL
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i+1,j)+C(i,j+1)
+        enddo
+      enddo
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(0:1,0:1)),stage(iloop)
+      do j=2,M-1
+       do i=2,N-1
+         A(i,j) = A(i+1,j)+A(i,j+1)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+       do j=2,M-1
+        do i=2,N-1
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif
+      deallocate (A, C)
+ 
+      end
+    
+C ------------------------------------------ACR2105   
+      subroutine acr2105 
+      integer,parameter :: N = 16,M=16, NL=1000
+      integer,allocatable::  A(:,:), C(:,:)
+      character*7 tname 
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow A(0:1,1:1)
+
+      tname='ACR2105'
+      allocate (A(N,M), C(N,M))  
+      
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      nloopi=NL
+      nloopj=NL
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i,j-1)+C(i+1,j)
+        enddo
+      enddo
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+!dvm$ parallel (j,i) on A(i,j),across(A(0:1,1:0)),stage(iloop)
+      do j=2,M-1
+       do i=2,N-1
+         A(i,j) = A(i,j-1)+A(i+1,j)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=2,M-1
+       do i=2,N-1         
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif      
+      deallocate (A, C) 
+
+      end
+       
+C -------------------------------------------ACR2106   
+         
+      subroutine acr2106
+      integer,parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2) :: A 
+
+      tname='ACR2106'
+      allocate (A(N,M), C(N,M))  
+	        
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+       do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i+2,j)+C(i,j+2)+C(i+2,j)+C(i-2,j)+C(i,j-2) 
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+          
+!dvm$ parallel (j,i) on A(i,j),across(A(2:2,2:2)),stage(iloop)
+       do j=3,M-2
+        do i=3,N-2
+          A(i,j) = A(i+2,j)+A(i,j+2)+A(i+2,j)+A(i-2,j)+A(i,j-2)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+       do j=3,M-2
+        do i=3,N-2
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+      
+      end   
+C -------------------------------------------ACR2107   
+         
+      subroutine acr2107
+
+      integer,parameter :: N = 16,M=16, NL=1000
+      integer,allocatable::  A(:,:), C(:,:)
+      character*7 tname 
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2) :: A 
+
+      tname='ACR2107'
+      allocate (A(N,M), C(N,M))  
+	        
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i+2,j)+C(i,j+2)+C(i,j-2)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(0:2,2:2)),stage(iloop)
+       do j=3,M-2
+        do i=3,N-2
+         A(i,j) =A(i+2,j)+A(i,j+2)+A(i,j-2)
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+       do j=3,M-2
+        do i=3,N-2
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)      
+ 
+      end   
+C -------------------------------------------ACR2108  
+         
+      subroutine acr2108
+      integer,parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2) :: A 
+
+      tname='ACR2108'
+      allocate (A(N,M), C(N,M))  
+	        
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+       do j=3,M-2
+         C(i,j) =C(i-1,j)+C(i,j-1)+C(i-2,j)+C(i+2,j)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+          
+!dvm$ parallel (j,i) on A(i,j),across(A(2:2,2:0)),stage(iloop)
+       do j=3,M-2
+        do i=3,N-2
+         A(i,j) = A(i-1,j)+A(i,j-1)+A(i-2,j)+A(i+2,j)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+       do j=3,M-2
+        do i=3,N-2   
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end          
+C -------------------------------------------ACR2109   
+         
+      subroutine acr2109
+      integer,parameter :: N = 16,M=16, NL=1000
+      integer,allocatable::  A(:,:), C(:,:)
+      character*7 tname 
+      integer nloopi,nloopj
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(2:2,0:2) :: A 
+
+      tname='ACR2109'
+      allocate (A(N,M), C(N,M))     
+      
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i,j+2)+ C(i+1,j)+C(i+2,j)
+        enddo
+      enddo
+
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+          
+!dvm$ parallel (j,i) on A(i,j),across(A(2:2,0:2)),stage(iloop)
+      do j=3,M-2
+        do i=3,N-2
+         A(i,j) = A(i,j+2)+ A(i+1,j)+A(i+2,j)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=3,M-2
+       do i=3,N-2      
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+      end  
+C -------------------------------------------ACR2110   
+         
+      subroutine acr2110
+      integer,parameter :: N = 16,M=16, NL=1000
+      integer,allocatable::  A(:,:), C(:,:)
+      character*7 tname 
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(3:3,3:3) :: A 
+
+      tname='ACR2110'
+      allocate (A(N,M), C(N,M)) 
+      
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=4,N-3
+        do j=4,M-3
+         C(i,j) =C(i+1,j)+C(i,j+2)+C(i+3,j)+C(i,j-3)+
+     * C(i-2,j)+C(i,j-1)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(3:3,3:3)),stage(iloop)
+      do j=4,M-3
+        do i=4,N-3
+         A(i,j) = A(i+1,j)+A(i,j+2)+A(i+3,j)+A(i,j-3)+
+     * A(i-2,j)+A(i,j-1)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=4,M-3
+        do i=4,N-3
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)      
+      end 
+C -------------------------------------------ACR2111   
+         
+      subroutine ACR2111
+      integer,parameter :: N = 16,M=16, NL=1000
+      integer,allocatable::  A(:,:), C(:,:)
+      character*7 tname 
+      integer nloopi,nloopj
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(3:3,0:3) :: A 
+
+      tname='ACR2111'
+      allocate (A(N,M), C(N,M)) 
+	        
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i,j)+C(i,j+1)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(0:0,0:1)),stage(iloop)
+      do j=3,M-2
+        do i=3,N-2
+          A(i,j) = A(i,j)+A(i,j+1)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=3,M-2
+        do i=3,N-2
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)      
+      end 
+C --------------------------------------------ACR2112  
+         
+      subroutine acr2112
+      integer,parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(0:3,3:3) :: A 
+
+      tname='ACR2112'
+      allocate (A(N,M), C(N,M))  
+	        
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i,j)+C(i+1,j)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(0:1,0:0)),stage(iloop)
+      do j=3,M-2
+        do i=3,N-2
+          A(i,j) = A(i,j)+A(i+1,j)
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+       do j=3,M-2
+        do i=3,N-2       
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end
+C --------------------------------------------ACR2113  
+         
+      subroutine acr2113
+      integer,parameter :: N = 16,M=16, NL=1000
+      integer,allocatable::  A(:,:), C(:,:)
+      character*7 tname 
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(3:3,3:0) :: A 
+
+      tname='ACR2113'
+      allocate (A(N,M), C(N,M))  
+      
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=4,N-3
+        do j=4,M-3
+         C(i,j) =C(i,j-3)+C(i+3,j)+C(i-3,j)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(3:3,3:0)),stage(iloop)
+      do j=4,M-3
+        do i=4,N-3
+         A(i,j) = A(i,j-3)+A(i+3,j)+A(i-3,j)
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=4,M-3
+       do i=4,N-3    
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end
+C --------------------------------------------ACR2114  
+         
+      subroutine acr2114
+      integer,parameter :: N = 16,M=16, NL=1000
+      integer,allocatable::  A(:,:), C(:,:)
+      character*7 tname 
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(3:0,3:3) :: A 
+
+      tname='ACR2114'
+      allocate (A(N,M), C(N,M)) 
+      
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=4,N-3
+        do j=4,M-3
+         C(i,j) =C(i-3,j)+C(i,j+3)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(3:0,3:3)),stage(iloop)
+      do j=4,M-3
+       do i=4,N-3
+         A(i,j) = A(i-3,j)+A(i,j+3)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=4,M-3
+       do i=4,N-3       
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end
+C --------------------------------------------ACR2115  
+         
+      subroutine acr2115
+      integer,parameter :: N = 59,M=59, NL=1000
+      character*7 tname 
+      integer,allocatable::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,BLOCK)   
+!dvm$ shadow(11:11,11:11) :: A 
+
+      tname='ACR2115'
+      allocate (A(N,M), C(N,M))   
+      
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=12,N-11
+        do j=12,M-11
+         C(i,j) =C(i+11,j)+C(i,j+10)+C(i+9,j)+
+     *C(i,j-11)+C(i-10,j)+C(i,j-9)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(11:11,11:11)),stage(iloop)
+      do j=12,M-11
+        do i=12,N-11
+         A(i,j) = A(i+11,j)+A(i,j+10)+A(i+9,j)+
+     *A(i,j-11)+A(i-10,j)+A(i,j-9)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=12,M-11
+        do i=12,N-11    
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end
+C -----------------------------------------------         
+      subroutine serial2(AR,N,M,NL)
+      integer AR(N,M)
+      integer NL 
+      do i=1,N
+        do j=1,M
+          AR(i,j) = NL+i+j
+        enddo
+      enddo                
+      end 
+        
+     
+    
+    
+      subroutine ansyes(name)
+      character*7 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*7 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/acr22.fdv

@@ -0,0 +1,995 @@
+       program ACR22
+     
+c    TESTING OF THE ACROSS CLAUSE'.       
+c    DISTRIBUTED ARRAY A(N,M) IS TO HAVE DIFFERENT 
+c    FLOW-DEP-LENGTH ON BOTH SIDES 
+
+      print *,'===START OF ACR22========================'
+C --------------------------------------------------
+      call acr2201
+C --------------------------------------------------
+      call acr2202
+C --------------------------------------------------
+      call acr2203
+C -------------------------------------------------
+      call acr2204
+C -------------------------------------------------
+      call acr2205
+C -------------------------------------------------
+      call acr2206
+C --------------------------------------------------
+      call acr2207
+C --------------------------------------------------
+      call acr2208
+C --------------------------------------------------
+      call acr2209
+C -------------------------------------------------
+      call acr2210
+C -------------------------------------------------
+      call acr2211
+C -------------------------------------------------
+      call acr2212
+C -------------------------------------------------
+      call acr2213
+C -------------------------------------------------
+      call acr2214
+C -------------------------------------------------
+      call acr2215
+C -------------------------------------------------
+      print *,'=== END OF ACR22 ========================= '    
+      end
+C ---------------------------------------------ACR2201
+      subroutine ACR2201
+     
+      integer, parameter :: N = 16,M=16, NL=1000
+
+     
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj
+                      
+!dvm$ distribute A(*,BLOCK)    
+      tname='ACR2201'
+      allocate (A(N,M), C(N,M))
+	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      nloopi=NL
+      nloopj=NL
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i+1,j)+C(i,j+1)+C(i-1,j)+C(i,j-1)
+        enddo
+      enddo
+
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region inout (C),out (A) 
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(1:1,1:1)),stage(iloop)
+      do j=2,M-1
+         do i=2,N-1
+            A(i,j) = A(i+1,j)+A(i,j+1)+A(i-1,j)+A(i,j-1)
+         enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=2,M-1
+       do i=2,N-1      
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)         
+          endif
+       enddo
+      enddo 
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	   
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+      
+      end
+C ---------------------------------------------ACR2202     
+      subroutine ACR2202
+        integer, parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj                      
+!dvm$ distribute A(BLOCK,*)    
+      tname='ACR2202'
+	  
+      do iloop=0,2	  
+      allocate (A(N,M), C(N,M))
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i+1,j)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+!dvm$ parallel (j,i) on A(i,j),across(A(0:1,0:0)),stage(iloop)
+      do j=2,M-1
+       do i=2,N-1
+        A(i,j) = A(i+1,j)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=2,M-1
+       do i=2,N-1
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo     
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      deallocate (A, C)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif                                                 
+               
+      end
+
+C -----------------------------------------ACR2203      
+      subroutine acr2203
+      integer, parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(*,BLOCK)   
+      tname='ACR2203'
+      allocate (A(N,M), C(N,M))
+	  
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      nloopi=NL
+      nloopj=NL
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i-1,j)+C(i,j+1)
+        enddo
+      enddo
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region in (C),out (A) 
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo                                                
+
+!dvm$ parallel (j,i) on A(i,j),across(A(1:0,0:1)),stage(iloop)
+      do j=2,M-1
+       do i=2,N-1
+         A(i,j) = A(i-1,j)+A(i,j+1)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=2,M-1
+       do i=2,N-1
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi,nloopj)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif
+      deallocate (A, C)
+    
+      end
+
+C ------------------------------------------ACR2204   
+      subroutine acr2204
+      integer, parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,*)   
+!dvm$ shadow A(1:1,0:1)
+      tname='ACR2204'
+      allocate (A(N,M), C(N,M))  
+	  	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      nloopi=NL
+      nloopj=NL
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i+1,j)+C(i,j+1)
+        enddo
+      enddo
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region in (C) 
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo                                                
+
+!dvm$ parallel (j,i) on A(i,j),across(A(0:1,0:1)),stage(iloop)
+      do j=2,M-1
+       do i=2,N-1
+         A(i,j) = A(i+1,j)+A(i,j+1)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=2,M-1
+        do i=2,N-1
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+        enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif
+      deallocate (A, C)    
+     
+      end
+    
+C ------------------------------------------ACR2205   
+      subroutine acr2205
+   
+      integer, parameter :: N = 16,M=16, NL=1000
+
+      
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(*,BLOCK)   
+!dvm$ shadow A(0:1,1:1)
+
+      tname='ACR2205'
+      allocate (A(N,M), C(N,M)) 
+	  	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      nloopi=NL
+      nloopj=NL
+      do i=2,N-1
+        do j=2,M-1
+         C(i,j) = C(i,j-1)+C(i+1,j)
+        enddo
+      enddo
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region  
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(0:1,1:0)),stage(iloop)
+      do j=2,M-1
+       do i=2,N-1
+         A(i,j) = A(i,j-1)+A(i+1,j)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=2,M-1
+       do i=2,N-1
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif      
+      deallocate (A, C) 
+
+      end
+       
+C -------------------------------------------ACR2206   
+         
+      subroutine acr2206
+      integer, parameter :: N = 16,M=16, NL=1000     
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,*)   
+!dvm$ shadow(2:2,2:2) :: A 
+      tname='ACR2206'
+      allocate (A(N,M), C(N,M))  
+	  	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i+2,j)+C(i,j+2)+C(i+2,j)+C(i-2,j)+C(i,j-2) 
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(2:2,2:2)),stage(iloop)
+      do j=3,M-2
+        do i=3,N-2
+         A(i,j) = A(i+2,j)+A(i,j+2)+A(i+2,j)+A(i-2,j)+A(i,j-2)
+        enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=3,M-2
+       do i=3,N-2      
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+      
+      end   
+C -------------------------------------------ACR2207   
+         
+      subroutine acr2207
+      integer, parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(*,BLOCK)   
+!dvm$ shadow(2:2,2:2) :: A 
+      tname='ACR2207'
+      allocate (A(N,M), C(N,M)) 
+	  	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i+2,j)+C(i,j+2)+C(i,j-2)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi)
+!dvm$ region  
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(0:2,2:2)),stage(iloop)
+      do j=3,M-2
+       do i=3,N-2
+        A(i,j) =A(i+2,j)+A(i,j+2)+A(i,j-2)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=3,M-2
+       do i=3,N-2
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)      
+ 
+      end   
+C -------------------------------------------ACR2208  
+         
+      subroutine acr2208
+      integer, parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,*)   
+!dvm$ shadow(2:2,2:2) :: A 
+      tname='ACR2208'
+      allocate (A(N,M), C(N,M))   
+	  	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i-1,j)+C(i,j-1)+C(i-2,j)+C(i+2,j)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region inout (C),out (A) 
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo                                                
+          
+!dvm$ parallel (j,i) on A(i,j),across(A(2:2,2:0)),stage(iloop)
+      do j=3,M-2
+       do i=3,N-2
+        A(i,j) = A(i-1,j)+A(i,j-1)+A(i-2,j)+A(i+2,j)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=3,M-2
+       do i=3,N-2
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+      end          
+C -------------------------------------------ACR2209   
+         
+      subroutine acr2209
+      integer, parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(*,BLOCK)   
+!dvm$ shadow(2:2,0:2) :: A 
+
+      tname='ACR2209'
+      allocate (A(N,M), C(N,M))  
+	  	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i,j+2)+ C(i+1,j)+C(i+2,j)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+!dvm$ actual (nloopi)
+!dvm$ region inout (C) 
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(2:2,0:2)),stage(iloop)
+      do j=3,M-2
+       do i=3,N-2
+        A(i,j) = A(i,j+2)+ A(i+1,j)+A(i+2,j)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=3,M-2
+       do i=3,N-2      
+         if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+         endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end  
+C -------------------------------------------ACR2210   
+         
+      subroutine acr2210
+      integer, parameter :: N = 16,M=16, NL=1000
+      
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,*)   
+!dvm$ shadow(3:3,3:3) :: A 
+
+      tname='ACR2210'
+      allocate (A(N,M), C(N,M))   
+	  
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=4,N-3
+        do j=4,M-3
+         C(i,j) =C(i+1,j)+C(i,j+2)+C(i+3,j)+C(i,j-3)+
+     * C(i-2,j)+C(i,j-1)    
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo                                                
+          
+!dvm$ parallel (j,i) on A(i,j),across(A(3:3,3:3)),stage(iloop)
+      do j=4,M-3
+       do i=4,N-3
+        A(i,j) = A(i+1,j)+A(i,j+2)+A(i+3,j)+A(i,j-3)+
+     * A(i-2,j)+A(i,j-1)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j = 4,M-3
+       do i= 4,N-3
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)      
+            
+      end 
+C -------------------------------------------ACR2211   
+         
+      subroutine ACR2211
+      integer, parameter :: N = 16,M=16, NL=1000
+      
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(*,BLOCK)   
+!dvm$ shadow(3:3,0:3) :: A 
+
+      tname='ACR2211'
+      allocate (A(N,M), C(N,M))  
+	  	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i,j)+C(i,j+1)       
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+
+!dvm$ actual (nloopi)
+!dvm$ region  
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(0:0,0:1)),stage(iloop)
+      do j=3,M-2
+       do i=3,N-2
+        A(i,j) = A(i,j)+A(i,j+1)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=3,M-2
+       do i=3,N-2       
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+     
+      end 
+C --------------------------------------------ACR2212  
+         
+      subroutine acr2212
+      integer, parameter :: N = 16,M=16, NL=1000
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,*)   
+!dvm$ shadow(0:3,3:3) :: A 
+
+      tname='ACR2212'
+      allocate (A(N,M), C(N,M))  
+	  	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=3,N-2
+        do j=3,M-2
+         C(i,j) =C(i,j)+C(i+1,j)
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region inout (C) 
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(0:1,0:0)),stage(iloop)
+      do j=3,M-2
+       do i=3,N-2
+        A(i,j) = A(i,j)+A(i+1,j)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=3,M-2
+       do i=3,N-2       
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end
+C --------------------------------------------ACR2213  
+         
+      subroutine acr2213
+      integer, parameter :: N = 16,M=16, NL=1000
+      
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(*,BLOCK)   
+!dvm$ shadow(3:3,3:0) :: A 
+
+      tname='ACR2213'
+      allocate (A(N,M), C(N,M)) 
+	  	  
+      do iloop=0,2
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=4,N-3
+        do j=4,M-3
+         C(i,j) =C(i,j-3)+C(i+3,j)+C(i-3,j)       
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(3:3,3:0)),stage(iloop)
+      do j=4,M-3
+       do i=4,N-3
+        A(i,j) = A(i,j-3)+A(i+3,j)+A(i-3,j)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=4,M-3
+       do i=4,N-3       
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end
+C --------------------------------------------ACR2214  
+         
+      subroutine acr2214
+      integer, parameter :: N = 16,M=16, NL=1000      
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(BLOCK,*)   
+!dvm$ shadow(3:0,3:3) :: A 
+
+      tname='ACR2214'
+      allocate (A(N,M), C(N,M)) 
+	  
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=4,N-3
+        do j=4,M-3
+         C(i,j) =C(i-3,j)+C(i,j+3)       
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+
+
+!dvm$ actual (nloopi,nloopj)
+!dvm$ region  
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo                                                          
+
+!dvm$ parallel (j,i) on A(i,j),across(A(3:0,3:3)),stage(iloop)
+      do j=4,M-3
+       do i=4,N-3
+        A(i,j) = A(i-3,j)+A(i,j+3)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=4,M-3
+       do i=4,N-3       
+          if (A(i,j).ne.c(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end
+C --------------------------------------------ACR2215  
+         
+      subroutine acr2215
+      integer, parameter :: N = 58,M=58, NL=1000
+      
+      character*7 tname 
+      integer, allocatable ::  A(:,:), C(:,:)
+      integer nloopi,nloopj 
+!dvm$ distribute A(*,BLOCK)   
+!dvm$ shadow(11:11,11:11) :: A 
+      tname='ACR2215'
+      allocate (A(N,M), C(N,M))   
+	  
+      do iloop=0,2	  
+      NNL=NL    
+      call serial2(C,N,M,NNL)
+      do i=12,N-11
+        do j=12,M-11
+         C(i,j) =C(i+11,j)+C(i,j+10)+C(i+9,j)+
+     *C(i,j-11)+C(i-10,j)+C(i,j-9)       
+        enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+
+!dvm$ actual (nloopi,nloopj,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (j,i) on A(i,j)
+      do j=1,M
+        do i=1,N
+         A(i,j) = NL+i+j
+        enddo
+      enddo
+
+!dvm$ parallel (j,i) on A(i,j),across(A(11:11,11:11)),stage(iloop)
+      do j=12,M-11
+       do i=12,N-11
+        A(i,j) = A(i+11,j)+A(i,j+10)+A(i+9,j)+
+     *A(i,j-11)+A(i-10,j)+A(i,j-9)
+       enddo
+      enddo
+  
+!dvm$ parallel (j,i) on A(i,j), reduction( min( nloopi),min(nloopj))
+      do j=12,M-11
+       do i=12,N-11    
+          if (A(i,j).ne.C(i,j)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+          endif
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (A, C)
+
+      end
+C -----------------------------------------------         
+      subroutine serial2(AR,N,M,NL)
+      integer AR(N,M)
+      integer NL 
+      do i=1,N
+       do j=1,M
+        AR(i,j) = NL+i+j
+        enddo
+      enddo
+      end    
+    
+      subroutine ansyes(name)
+      character*7 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*7 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/acr31.fdv

@@ -0,0 +1,781 @@
+      program ACR31
+
+c    TESTING OF THE ACROSS CLAUSE'.       
+c    DISTRIBUTED ARRAY A(N,M,K) IS TO HAVE DIFFERENT 
+c    FLOW-DEP-LENGTH ON BOTH SIDES      
+
+      print *,'===START OF ACR31========================'
+C --------------------------------------------------
+      call acr3101
+C --------------------------------------------------
+      call acr3102
+C --------------------------------------------------
+      call acr3103
+C -------------------------------------------------
+      call acr3104
+C -------------------------------------------------
+      call acr3105
+C -------------------------------------------------
+      call acr3106
+C --------------------------------------------------
+      call acr3107
+C --------------------------------------------------
+      call acr3108
+C----------------------------------------------------
+      call acr3109
+C----------------------------------------------------
+
+C
+C
+      print *,'=== END OF ACR31 ========================= '    
+      end
+C ---------------------------------------------ACR3101
+      subroutine acr3101
+     
+      integer, parameter :: N = 16,M=8,K=8, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,BLOCK)       
+      tname='ACR3101'     
+      allocate (A(N,M,K), C(N,M,K))
+      
+      do iloop=0,2	 	  
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=2,N-1
+       do j=2,M-1
+         do ii=2,K-1
+         C(i,j,ii) = C(i+1,j,ii)+C(i,j+1,ii)+C(i,j,ii+1)+C(i-1,j,ii)+
+     *C(i,j-1,ii)+ C(i,j,ii-1)
+         enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo                                              
+!dvm$ parallel (ii,j,i) on A(i,j,ii),across(A(1:1,1:1,1:1)),
+!dvm$*stage(iloop)
+      do ii=2,K-1
+       do j=2,M-1
+         do i=2,N-1
+          A(i,j,ii) = A(i+1,j,ii)+A(i,j+1,ii)+A(i,j,ii+1)+A(i-1,j,ii)+
+     *A(i,j-1,ii)+ A(i,j,ii-1)
+         enddo
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=2,K-1
+       do j=2,M-1
+        do i=2,N-1       
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+C ---------------------------------------------ACR3102     
+      subroutine acr3102
+     
+      integer, parameter :: N = 16,M=10,K=10, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2,2:2) :: A     
+      tname='ACR3102'     
+      allocate (A(N,M,K), C(N,M,K))
+      
+      do iloop=0,2	 	  
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         C(i,j,ii)=C(i+2,j,ii)    +C(i,j-2,ii)  +
+     *            C(i,j,ii-1)      +C(i-1,j,ii) +
+     *            C(i+1,j,ii)      +C(i,j-1,ii) +
+     *            C(i,j+2,ii)      +C(i,j,ii+2)  
+
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region in (C) 
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo                                             
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(1:2,2:2,1:2)),
+!dvm$*stage(iloop)
+      do ii=3,K-2
+       do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii)=A(i+2,j,ii)    +A(i,j-2,ii)  +
+     *            A(i,j,ii-1)      +A(i-1,j,ii) +
+     *            A(i+1,j,ii)      +A(i,j-1,ii) +
+     *            A(i,j+2,ii)      +A(i,j,ii+2)  
+         enddo
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=3,K-2
+       do j=3,M-2
+        do i=3,N-2       
+          if (A(i,j,ii).ne.C(i,j,ii)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)         
+          endif
+        enddo
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi) 
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+C ---------------------------------------------ACR3103     
+      subroutine acr3103     
+      integer, parameter :: N = 16,M=10,K=10, NL=1000      
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2,2:2) :: A     
+      tname='ACR3103'     
+      allocate (A(N,M,K), C(N,M,K))
+      
+      do iloop=0,2	 	  
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         C(i,j,ii) =C(i+2,j,ii)+C(i,j+2,ii)+C(i,j,ii+2)+
+     *              C(i,j-2,ii)+ C(i,j-1,ii)+C(i+1,j,ii)+
+     *              C(i,j+1,ii)+C(i,j,ii+1)
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo                                              
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(0:2,2:2,0:2)),
+!dvm$*stage(iloop)
+      do ii=3,K-2
+       do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii) =A(i+2,j,ii)+A(i,j+2,ii)+A(i,j,ii+2)+
+     *              A(i,j-2,ii)+ A(i,j-1,ii)+A(i+1,j,ii)+
+     *              A(i,j+1,ii)+A(i,j,ii+1)
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=3,K-2
+       do j=3,M-2
+        do i=3,N-2       
+          if (A(i,j,ii).ne.C(i,j,ii)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)         
+          endif
+        enddo
+       enddo
+      enddo
+
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+C ---------------------------------------------ACR3104     
+      subroutine acr3104     
+      integer, parameter :: N = 16,M=10,K=10, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2,2:2) :: A     
+      tname='ACR3104'     
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         C(i,j,ii) =C(i+2,j,ii)+C(i,j,ii-2)+
+     *C(i-2,j,ii)+ C(i,j-2,ii)+C(i-1,j,ii)+C(i,j-1,ii)+
+     *C(i,j,ii-1)+C(i+1,j,ii)
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii)
+!dvm$ region  
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo                                              
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(2:2,2:0,2:0)),
+!dvm$*stage(iloop)
+      do ii=3,K-2
+       do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii) =A(i+2,j,ii)+A(i,j,ii-2)+
+     *A(i-2,j,ii)+ A(i,j-2,ii)+A(i-1,j,ii)+A(i,j-1,ii)+
+     *A(i,j,ii-1)+A(i+1,j,ii)
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=3,K-2
+       do j=3,M-2
+        do i=3,N-2       
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+C ---------------------------------------------ACR3105     
+      subroutine acr3105
+      integer, parameter :: N = 16,M=10,K=10, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(0:2,2:2,0:2) :: A     
+      tname='ACR3105'     
+      allocate (A(N,M,K), C(N,M,K))
+      
+      do iloop=0,2	 	  
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         C(i,j,ii) =C(i+2,j,ii)+C(i,j+2,ii)+C(i,j,ii+2)+
+     *   C(i,j-2,ii)+C(i,j-1,ii)+C(i+1,j,ii)+C(i,j+1,ii)+
+     *   C(i,j,ii+1)
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region in (C) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo                                              
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(0:2,2:2,0:2)),
+!dvm$*stage(iloop)
+      do ii=3,K-2
+       do j=3,M-2
+         do i=3,N-2
+         A(i,j,ii) =A(i+2,j,ii)+A(i,j+2,ii)+A(i,j,ii+2)+
+     *   A(i,j-2,ii)+A(i,j-1,ii)+A(i+1,j,ii)+A(i,j+1,ii)+
+     *   A(i,j,ii+1)
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=3,K-2
+       do j=3,M-2
+        do i=3,N-2
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+
+C --------------------------------------------ACR3106  
+      subroutine acr3106   
+      integer, parameter :: N = 16,M=16,K=16, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(3:3,3:3,3:3) :: A     
+      tname='ACR3106'     
+      allocate (A(N,M,K), C(N,M,K))
+      
+      do iloop=0,2	 	  
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=4,N-3
+       do j=4,M-3
+         do ii=4,K-3
+          C(i,j,ii) = C(i+3,j,ii)+C(i,j+3,ii)+C(i,j,ii+3)+
+     *               C(i-3,j,ii)+C(i,j-3,ii)+C(i,j,ii-3)+
+     *               C(i+2,j,ii)+C(i,j+2,ii)+C(i,j,ii+2)+
+     *               C(i-2,j,ii)+C(i,j-2,ii)+C(i,j,ii-2)+
+     *               C(i+1,j,ii)+C(i,j+1,ii)+C(i,j,ii+1)+
+     *               C(i-1,j,ii)+C(i,j-1,ii)+C(i,j,ii-1)
+         enddo 
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo                                              
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(3:3,3:3,3:3)),
+!dvm$*stage(iloop)
+      do ii=4,K-3
+       do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii) = A(i+3,j,ii)+A(i,j+3,ii)+A(i,j,ii+3)+
+     *               A(i-3,j,ii)+A(i,j-3,ii)+A(i,j,ii-3)+
+     *               A(i+2,j,ii)+A(i,j+2,ii)+A(i,j,ii+2)+
+     *               A(i-2,j,ii)+A(i,j-2,ii)+A(i,j,ii-2)+
+     *               A(i+1,j,ii)+A(i,j+1,ii)+A(i,j,ii+1)+
+     *               A(i-1,j,ii)+A(i,j-1,ii)+A(i,j,ii-1)
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=4,K-3
+       do j=4,M-3
+        do i=4,N-3    
+          if (A(i,j,ii).ne.C(i,j,ii)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)         
+          endif
+        enddo
+       enddo
+      enddo
+
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate(A,C)
+      end
+           
+         
+C --------------------------------------------ACR3107  
+      subroutine acr3107   
+      integer, parameter :: N = 16,M=16,K=16, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(3:3,0:3,3:0) :: A     
+      tname='ACR3107'     
+      allocate (A(N,M,K), C(N,M,K))
+      
+      do iloop=0,2	 	  
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=4,N-3
+       do j=4,M-3
+         do ii=4,K-3
+          C(i,j,ii) = C(i+3,j,ii)+C(i,j+3,ii)+C(i-3,j,ii)+
+     *               C(i,j,ii-3)+C(i+2,j,ii)+C(i,j+2,ii)+
+     *               C(i-2,j,ii)+C(i,j,ii-2)+
+     *               C(i+1,j,ii)+C(i,j+1,ii)+C(i+1,j,ii)+
+     *               C(i,j+1,ii)+C(i-1,j,ii)+C(i,j,ii-1) 
+         enddo 
+       enddo
+      enddo
+
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo                                              
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(3:3,0:3,3:0)),
+!dvm$*stage(iloop)
+      do ii=4,K-3
+       do j=4,M-3
+         do i=4,N-3
+         A(i,j,ii) = A(i+3,j,ii)+A(i,j+3,ii)+A(i-3,j,ii)+
+     *               A(i,j,ii-3)+A(i+2,j,ii)+A(i,j+2,ii)+
+     *               a(i-2,j,ii)+A(i,j,ii-2)+
+     *               A(i+1,j,ii)+A(i,j+1,ii)+A(i+1,j,ii)+
+     *               A(i,j+1,ii)+A(i-1,j,ii)+A(i,j,ii-1)   
+        enddo
+       enddo
+      enddo
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=4,K-3
+       do j=4,M-3
+        do i=4,N-3    
+          if (A(i,j,ii).ne.C(i,j,ii)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)         
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+                    
+C --------------------------------------------ACR3108  
+      subroutine acr3108   
+      integer, parameter :: N = 16,M=16,K=16, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(0:3,0:3,0:3) :: A     
+      tname='ACR3108'     
+      allocate (A(N,M,K), C(N,M,K))
+      
+      do iloop=0,2	 	  
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+
+      do i=1,N-3
+       do j=1,M-3
+         do ii=1,K-3
+          C(i,j,ii) = C(i+3,j,ii)+C(i,j+3,ii)+C(i,j,ii+3)+
+     *               C(i+2,j,ii)+C(i,j+2,ii)+C(i,j,ii+2)+
+     *               C(i+1,j,ii)+C(i,j+1,ii)+C(i,j,ii+1) 
+         enddo 
+       enddo
+      enddo
+
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region  
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo                                              
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(0:3,0:3,0:3)),
+!dvm$*stage(iloop)
+      do ii=1,K-3
+       do j=1,M-3
+         do i=1,N-3
+          A(i,j,ii) = A(i+3,j,ii)+A(i,j+3,ii)+A(i,j,ii+3)+
+     *               A(i+2,j,ii)+A(i,j+2,ii)+A(i,j,ii+2)+
+     *               A(i+1,j,ii)+A(i,j+1,ii)+A(i,j,ii+1)    
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=4,K-3
+       do j=4,M-3
+        do i=4,N-3    
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+           
+C --------------------------------------------ACR3109  
+      subroutine acr3109   
+      integer, parameter :: N = 58,M=58,K=58, NL=1000      
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(11:11,11:11,11:11) :: A     
+      tname='ACR3109'     
+      allocate (A(N,M,K), C(N,M,K))
+      
+      do iloop=0,2	 	  
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=12,N-11
+       do j=12,M-11
+         do ii=12,K-11
+          C(i,j,ii) = C(i+11,j,ii)+C(i,j+11,ii)+C(i,j,ii+11)+
+     *               C(i-11,j,ii)+C(i,j-11,ii)+C(i,j,ii-11)+
+     *               C(i+10,j,ii)+C(i,j+10,ii)+C(i,j,ii+10)+
+     *               C(i-10,j,ii)+C(i,j-10,ii)+C(i,j,ii-10)+
+     *               C(i-9,j,ii) +C(i,j-9,ii) +C(i,j,ii-9)+
+     *               C(i+9,j,ii) +C(i,j+9,ii) +C(i,j,ii+9)  
+         enddo 
+        enddo
+      enddo
+
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(11:11,11:11,11:11)),
+!dvm$*stage(iloop)
+      do ii=12,K-11
+       do j=12,M-11
+         do i=12,N-11
+          A(i,j,ii) = A(i+11,j,ii)+A(i,j+11,ii)+A(i,j,ii+11)+
+     *               A(i-11,j,ii)+A(i,j-11,ii)+A(i,j,ii-11)+
+     *               A(i+10,j,ii)+A(i,j+10,ii)+A(i,j,ii+10)+
+     *               A(i-10,j,ii)+A(i,j-10,ii)+A(i,j,ii-10)+
+     *               A(i-9,j,ii)+A(i,j-9,ii)+A(i,j,ii-9)+
+     *               A(i+9,j,ii)+A(i,j+9,ii)+A(i,j,ii+9)  
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=4,K-3
+       do j=4,M-3
+        do i=4,N-3    
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+
+C -----------------------------------------------         
+      subroutine serial3(AR,N,M,K,NL)
+      integer AR(N,M,K)
+      integer NL 
+      do i=1,N
+       do j=1,M
+        do ii=1,K
+         AR(i,j,ii) = NL+i+j+ii
+        enddo
+       enddo
+      enddo
+      end 
+    
+      subroutine ansyes(name)
+      character*7 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*7 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/acr32.fdv

@@ -0,0 +1,772 @@
+      program ACR32
+
+c    TESTING OF THE ACROSS CLAUSE'.       
+c    DISTRIBUTED ARRAY A(N,M,K) IS TO HAVE DIFFERENT 
+c    FLOW-DEP-LENGTH ON BOTH SIDES      
+
+      print *,'===START OF ACR32========================'
+C --------------------------------------------------
+      call acr3201
+C --------------------------------------------------
+      call acr3202
+C --------------------------------------------------
+      call acr3203
+C -------------------------------------------------
+      call acr3204
+C -------------------------------------------------
+      call acr3205
+C -------------------------------------------------
+      call acr3206
+C --------------------------------------------------
+      call acr3207
+C --------------------------------------------------
+      call acr3208
+C----------------------------------------------------
+      call acr3209
+C----------------------------------------------------
+
+C
+C
+      print *,'=== END OF ACR32 ========================= '    
+      end
+C ---------------------------------------------ACR3201
+      subroutine acr3201    
+      integer, parameter :: N = 16,M=8,K=8, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(*,BLOCK,BLOCK)     
+      tname='ACR3201'
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=2,N-1
+       do j=2,M-1
+         do ii=2,K-1
+          C(i,j,ii) = C(i+1,j,ii)+C(i,j+1,ii)+C(i,j,ii+1)+C(i-1,j,ii)+
+     *C(i,j-1,ii)+ C(i,j,ii-1)
+         enddo 
+       enddo
+      enddo
+
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),across(A(1:1,1:1,1:1)),
+!dvm$*stage(iloop)
+      do ii=2,K-1
+       do j=2,M-1
+         do i=2,N-1
+          A(i,j,ii)=A(i+1,j,ii)+A(i,j+1,ii)+A(i,j,ii+1)+A(i-1,j,ii)+
+     *A(i,j-1,ii)+ A(i,j,ii-1)
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=2,K-1
+       do j=2,M-1
+         do i=2,N-1       
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+         enddo
+        enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+C ---------------------------------------------ACR3202     
+      subroutine acr3202
+      integer, parameter :: N = 16,M=10,K=10, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,*,BLOCK)   
+!dvm$ shadow(2:2,2:2,2:2) :: A     
+      tname='ACR3202'
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         C(i,j,ii)=C(i+2,j,ii)+C(i,j-2,ii)  +
+     *            C(i,j,ii-1)+C(i-1,j,ii) +
+     *            C(i+1,j,ii)+C(i,j-1,ii) +
+     *            C(i,j+2,ii)+C(i,j,ii+2)  
+
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(1:2,2:2,1:2)),
+!dvm$*stage(iloop)
+      do ii=3,K-2
+       do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii)=A(i+2,j,ii)+A(i,j-2,ii)  +
+     *            A(i,j,ii-1)+A(i-1,j,ii) +
+     *            A(i+1,j,ii)+A(i,j-1,ii) +
+     *            A(i,j+2,ii)+A(i,j,ii+2)  
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=3,K-2
+       do j=3,M-2
+        do i=3,N-2       
+          if (A(i,j,ii).ne.C(i,j,ii)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)         
+          endif
+        enddo
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+C ---------------------------------------------ACR3203     
+      subroutine acr3203     
+      integer, parameter :: N = 16,M=10,K=10, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,*)   
+!dvm$ shadow(2:2,2:2,2:2) :: A     
+      tname='ACR3203'
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         C(i,j,ii) =C(i+2,j,ii)+C(i,j+2,ii)+C(i,j,ii+2)+
+     *              C(i,j-2,ii)+ C(i,j-1,ii)+C(i+1,j,ii)+
+     *              C(i,j+1,ii)+C(i,j,ii+1)
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii)
+!dvm$ region in (C) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(0:2,2:2,0:2)),
+!dvm$*stage(iloop)
+      do ii=3,K-2
+       do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii) =A(i+2,j,ii)+A(i,j+2,ii)+A(i,j,ii+2)+
+     *              A(i,j-2,ii)+ A(i,j-1,ii)+A(i+1,j,ii)+
+     *              A(i,j+1,ii)+A(i,j,ii+1)
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2       
+          if (A(i,j,ii).ne.C(i,j,ii)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)        
+          endif
+         enddo
+        enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+C ---------------------------------------------ACR3204     
+      subroutine acr3204     
+      integer, parameter :: N = 16,M=10,K=10, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(*,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2,2:2) :: A     
+      tname='ACR3204'     
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         C(i,j,ii) =C(i+2,j,ii)+C(i,j,ii-2)+
+     *C(i-2,j,ii)+ C(i,j-2,ii)+C(i-1,j,ii)+C(i,j-1,ii)+
+     *C(i,j,ii-1)+C(i+1,j,ii)
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(2:2,2:0,2:0)),
+!dvm$*stage(iloop)
+      do ii=3,K-2
+       do j=3,M-2
+         do i=3,N-2
+         A(i,j,ii) =A(i+2,j,ii)+A(i,j,ii-2)+
+     *A(i-2,j,ii)+ A(i,j-2,ii)+A(i-1,j,ii)+A(i,j-1,ii)+
+     *A(i,j,ii-1)+A(i+1,j,ii)
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=3,K-2
+       do j=3,M-2
+        do i=3,N-2       
+          if (A(i,j,ii).ne.C(i,j,ii)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+C ---------------------------------------------ACR3205     
+      subroutine acr3205
+      integer, parameter :: N = 16,M=10,K=10, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,*,BLOCK)   
+!dvm$ shadow(0:2,2:2,0:2) :: A     
+      tname='ACR3205'     
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         C(i,j,ii) =C(i+2,j,ii)+C(i,j+2,ii)+C(i,j,ii+2)+
+     *   C(i,j-2,ii)+C(i,j-1,ii)+C(i+1,j,ii)+C(i,j+1,ii)+
+     *   C(i,j,ii+1)
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(0:2,2:2,0:2)),
+!dvm$*stage(iloop)
+      do ii=3,K-2
+       do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii) =A(i+2,j,ii)+A(i,j+2,ii)+A(i,j,ii+2)+
+     *   A(i,j-2,ii)+A(i,j-1,ii)+A(i+1,j,ii)+A(i,j+1,ii)+
+     *   A(i,j,ii+1)
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=3,K-2
+       do j=3,M-2
+        do i=3,N-2       
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+
+C --------------------------------------------ACR3206  
+      subroutine acr3206   
+      integer, parameter :: N = 16,M=16,K=16, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,*)   
+!dvm$ shadow(3:3,3:3,3:3) :: A     
+      tname='ACR3206'     
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=4,N-3
+       do j=4,M-3
+         do ii=4,K-3
+          C(i,j,ii) = C(i+3,j,ii)+C(i,j+3,ii)+C(i,j,ii+3)+
+     *               C(i-3,j,ii)+C(i,j-3,ii)+C(i,j,ii-3)+
+     *               C(i+2,j,ii)+C(i,j+2,ii)+C(i,j,ii+2)+
+     *               C(i-2,j,ii)+C(i,j-2,ii)+C(i,j,ii-2)+
+     *               C(i+1,j,ii)+C(i,j+1,ii)+C(i,j,ii+1)+
+     *               C(i-1,j,ii)+C(i,j-1,ii)+C(i,j,ii-1)
+         enddo 
+       enddo
+      enddo
+
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C) 
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(3:3,3:3,3:3)),
+!dvm$*stage(iloop)
+      do ii=4,K-3
+       do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii) = A(i+3,j,ii)+A(i,j+3,ii)+A(i,j,ii+3)+
+     *               A(i-3,j,ii)+A(i,j-3,ii)+A(i,j,ii-3)+
+     *               A(i+2,j,ii)+A(i,j+2,ii)+A(i,j,ii+2)+
+     *               A(i-2,j,ii)+A(i,j-2,ii)+A(i,j,ii-2)+
+     *               A(i+1,j,ii)+A(i,j+1,ii)+A(i,j,ii+1)+
+     *               A(i-1,j,ii)+A(i,j-1,ii)+A(i,j,ii-1)
+         enddo 
+       enddo
+      enddo
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=4,K-3
+       do j=4,M-3
+        do i=4,N-3    
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+           
+         
+C --------------------------------------------ACR3207  
+      subroutine acr3207   
+      integer, parameter :: N = 16,M=16,K=16, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(*,BLOCK,BLOCK)   
+!dvm$ shadow(3:3,0:3,3:0) :: A     
+      tname='ACR3207'     
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=4,N-3
+       do j=4,M-3
+         do ii=4,K-3
+          C(i,j,ii) = C(i+3,j,ii)+C(i,j+3,ii)+C(i-3,j,ii)+
+     *               C(i,j,ii-3)+C(i+2,j,ii)+C(i,j+2,ii)+
+     *               C(i-2,j,ii)+C(i,j,ii-2)+
+     *               C(i+1,j,ii)+C(i,j+1,ii)+C(i+1,j,ii)+
+     *               C(i,j+1,ii)+C(i-1,j,ii)+C(i,j,ii-1) 
+         enddo 
+       enddo
+      enddo
+
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(3:3,0:3,3:0)),
+!dvm$*stage(iloop)
+      do ii=4,K-3
+       do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii) = A(i+3,j,ii)+A(i,j+3,ii)+A(i-3,j,ii)+
+     *               A(i,j,ii-3)+A(i+2,j,ii)+A(i,j+2,ii)+
+     *               a(i-2,j,ii)+A(i,j,ii-2)+
+     *               A(i+1,j,ii)+A(i,j+1,ii)+A(i+1,j,ii)+
+     *               A(i,j+1,ii)+A(i-1,j,ii)+A(i,j,ii-1)   
+         enddo
+       enddo
+      enddo
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=4,K-3
+       do j=4,M-3
+        do i=4,N-3    
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+	  
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+           
+         
+C --------------------------------------------ACR3208  
+      subroutine acr3208   
+      integer, parameter :: N = 16,M=16,K=16, NL=1000
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,*,BLOCK)   
+!dvm$ shadow(0:3,0:3,0:3) :: A     
+      tname='ACR3208'     
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=1,N-3
+       do j=1,M-3
+         do ii=1,K-3
+          C(i,j,ii) = C(i+3,j,ii)+C(i,j+3,ii)+C(i,j,ii+3)+
+     *               C(i+2,j,ii)+C(i,j+2,ii)+C(i,j,ii+2)+
+     *               C(i+1,j,ii)+C(i,j+1,ii)+C(i,j,ii+1) 
+         enddo 
+       enddo
+      enddo
+
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region  
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+        enddo
+      enddo
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(0:3,0:3,0:3)),
+!dvm$*stage(iloop)
+      do ii=1,K-3
+       do j=1,M-3
+        do i=1,N-3
+         A(i,j,ii) = A(i+3,j,ii)+A(i,j+3,ii)+A(i,j,ii+3)+
+     *               A(i+2,j,ii)+A(i,j+2,ii)+A(i,j,ii+2)+
+     *               A(i+1,j,ii)+A(i,j+1,ii)+A(i,j,ii+1)    
+         enddo 
+       enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=4,K-3
+       do j=4,M-3
+        do i=4,N-3    
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end                   
+
+C --------------------------------------------ACR3209  
+      subroutine acr3209   
+      integer, parameter :: N = 58,M=58,K=58, NL=1000    
+      integer,allocatable :: A(:,:,:), C(:,:,:)
+      integer nloopi,nloopj,nloopii
+      character*7 tname 
+!dvm$ distribute A(BLOCK,BLOCK,*)   
+!dvm$ shadow(11:11,11:11,11:11) :: A     
+      tname='ACR3209'     
+      allocate (A(N,M,K), C(N,M,K))
+	        
+      do iloop=0,2	 
+      NNL=NL    
+      call serial3(C,N,M,K,NNL)
+      do i=12,N-11
+       do j=12,M-11
+         do ii=12,K-11
+          C(i,j,ii) = C(i+11,j,ii)+C(i,j+11,ii)+C(i,j,ii+11)+
+     *               C(i-11,j,ii)+C(i,j-11,ii)+C(i,j,ii-11)+
+     *               C(i+10,j,ii)+C(i,j+10,ii)+C(i,j,ii+10)+
+     *               C(i-10,j,ii)+C(i,j-10,ii)+C(i,j,ii-10)+
+     *               C(i-9,j,ii) +C(i,j-9,ii) +C(i,j,ii-9)+
+     *               C(i+9,j,ii) +C(i,j+9,ii) +C(i,j,ii+9)  
+         enddo 
+       enddo
+      enddo
+
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,C)
+!dvm$ region inout (C),out (A) 
+
+
+!dvm$ parallel (ii,j,i) on A(i,j,ii)
+      do ii=1,K
+       do j=1,M
+         do i=1,N
+          A(i,j,ii) = NL+i+j+ii
+         enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*across(A(11:11,11:11,11:11)),
+!dvm$*stage(iloop)
+      do ii=12,K-11
+       do j=12,M-11
+        do i=12,N-11
+         A(i,j,ii) = A(i+11,j,ii)+A(i,j+11,ii)+A(i,j,ii+11)+
+     *               A(i-11,j,ii)+A(i,j-11,ii)+A(i,j,ii-11)+
+     *               A(i+10,j,ii)+A(i,j+10,ii)+A(i,j,ii+10)+
+     *               A(i-10,j,ii)+A(i,j-10,ii)+A(i,j,ii-10)+
+     *               A(i-9,j,ii)+A(i,j-9,ii)+A(i,j,ii-9)+
+     *               A(i+9,j,ii)+A(i,j+9,ii)+A(i,j,ii+9)  
+         enddo 
+        enddo
+      enddo
+  
+!dvm$ parallel (ii,j,i) on A(i,j,ii),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii))
+      do ii=4,K-3
+       do j=4,M-3
+        do i=4,N-3    
+          if (A(i,j,ii).ne.C(i,j,ii)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+          endif
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+      enddo
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, C)
+      end
+
+C -----------------------------------------------         
+      subroutine serial3(AR,N,M,K,NL)
+      integer AR(N,M,K)
+      integer NL 
+      do i=1,N
+       do j=1,M
+        do ii=1,K
+         AR(i,j,ii) = NL+i+j+ii
+        enddo
+       enddo
+      enddo
+      end 
+    
+      subroutine ansyes(name)
+      character*7 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*7 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/acr41.fdv

@@ -0,0 +1,887 @@
+      program ACR41
+
+c    TESTING OF THE ACROSS CLAUSE'.       
+c    DISTRIBUTED ARRAY A(N,M,K,L) IS TO HAVE DIFFERENT 
+c    FLOW-DEP-LENGTH ON BOTH SIDES      
+
+      print *,'===START OF ACR41========================'
+C --------------------------------------------------
+      call acr4101
+C --------------------------------------------------
+      call acr4102
+C --------------------------------------------------
+      call acr4103
+C -------------------------------------------------
+      call acr4104
+C -------------------------------------------------
+      call acr4105
+C -------------------------------------------------
+      call acr4106
+C --------------------------------------------------
+      call acr4107
+C --------------------------------------------------
+      call acr4108
+C----------------------------------------------------
+c     call acr4109
+C----------------------------------------------------
+
+C
+C
+      print *,'=== END OF ACR41 ========================= '    
+      end
+C ---------------------------------------------ACR4101 
+      subroutine ACR4101    
+      integer, parameter :: N = 16,M=8,K=8,L=8, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(BLOCK,BLOCK,BLOCK,BLOCK)      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4101'     
+      allocate (B(N,M,K,L),A(N,M,K,L),C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=2,N-1
+       do j=2,M-1
+         do ii=2,K-1
+          do jj=2,L-1
+           C(i,j,ii,jj)=
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+1)+
+     *   C(i-1,j,ii,jj)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii-1,jj)+ C(i,j,ii,jj-1)
+         enddo 
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in(C,B),out (A) 
+
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+        do ii=1,K
+         do j=1,M
+          do i=1,N
+           A(i,j,ii,jj) = NL+i+j+ii+jj
+          enddo
+         enddo
+        enddo
+       enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(1:1,1:1,1:1,1:1))
+      do jj=2,L-1
+       do ii=2,K-1
+        do j=2,M-1
+         do i=2,N-1
+          A(i,j,ii,jj)=
+     *   A(i+1,j,ii,jj)+A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+A(i,j,ii,jj+1)+
+     *   A(i-1,j,ii,jj)+A(i,j-1,ii,jj)+
+     *   A(i,j,ii-1,jj)+A(i,j,ii,jj-1)
+         enddo 
+        enddo
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=2,L-1
+       do ii=2,K-1
+        do j=2,M-1
+         do i=2,N-1         
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+           endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A,B, C)
+      end
+C ---------------------------------------------ACR4102     
+      subroutine ACR4102    
+      integer, parameter :: N = 16,M=10,K=10,L=10, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(BLOCK,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2,2:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4102'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj) =
+     *   C(i+2,j,ii,jj)+ C(i,j+2,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+2)+
+     *   C(i-1,j,ii,jj)+ C(i,j-2,ii,jj)+
+     *   C(i,j,ii-2,jj)+ C(i,j,ii,jj-1)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii,jj+1)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo 
+      enddo 
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region  
+
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),across(A(1:2,2:2,2:1,1:2))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj) =
+     *   A(i+2,j,ii,jj)+ A(i,j+2,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj+2)+
+     *   A(i-1,j,ii,jj)+ A(i,j-2,ii,jj)+
+     *   A(i,j,ii-2,jj)+ A(i,j,ii,jj-1)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii,jj+1)+ A(i,j-1,ii,jj)+
+     *   A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end
+C -----------------------------------------ACR4103      
+      subroutine ACR4103     
+      integer, parameter :: N = 16,M=10,K=10,L=10, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(BLOCK,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2,2:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4103'     
+      allocate (B(N,M,K,L), C(N,M,K,L), A(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj) =  C(i-2,j,ii,jj)+
+     *   C(i,j-2,ii,jj)+ C(i,j,ii-2,jj)+
+     *   C(i,j,ii,jj-2)+ C(i-1,j,ii,jj)+
+     *   C(i,j-1,ii,jj)+ C(i,j,ii-1,jj)+
+     *   C(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo  
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A) 
+
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(2:0,2:2,2:0,2:0))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj) =  A(i-2,j,ii,jj)+
+     *   A(i,j-2,ii,jj)+ A(i,j,ii-2,jj)+
+     *   A(i,j,ii,jj-2)+ A(i-1,j,ii,jj)+
+     *   A(i,j-1,ii,jj)+ A(i,j,ii-1,jj)+
+     *   A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A ,B, C)
+      end 
+C ------------------------------------------ACR4104   
+      subroutine ACR4104     
+      integer, parameter :: N = 16,M=10,K=10,L=10, NL=1000            
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(BLOCK,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2,2:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4104'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj) =  C(i+2,j,ii,jj)+
+     *   C(i,j,ii,jj+2)+ C(i-2,j,ii,jj)+
+     *   C(i,j-2,ii,jj)+ C(i,j,ii-2,jj)+
+     *   C(i+1,j,ii,jj)+ C(i,j,ii,jj+1)+
+     *   C(i-1,j,ii,jj)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii-1,jj)
+         enddo
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C) 
+
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(2:2,2:0,2:0,0:2))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj) =  A(i+2,j,ii,jj)+
+     *   A(i,j,ii,jj+2)+ A(i-2,j,ii,jj)+
+     *   A(i,j-2,ii,jj)+ A(i,j,ii-2,jj)+
+     *   A(i+1,j,ii,jj)+ A(i,j,ii,jj+1)+
+     *   A(i-1,j,ii,jj)+ A(i,j-1,ii,jj)+
+     *   A(i,j,ii-1,jj)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate ( A, B, C)
+      end  
+C ------------------------------------------ACR4105
+      subroutine ACR4105
+      integer, parameter :: N = 16,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(BLOCK,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:0,0:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4105'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj)=
+     *   C(i+2,j,ii,jj)+ C(i,j,ii+2,jj)+
+     *   C(i,j,ii,jj+2)+ C(i-2,j,ii,jj)+
+     *   C(i,j-2,ii,jj)+ C(i,j,ii,jj-2)+
+     *   C(i+1,j,ii,jj)+ C(i,j,ii+1,jj)+
+     *   C(i,j,ii,jj+1)+ C(i-1,j,ii,jj)+
+     *   C(i,j-1,ii,jj)+ C(i,j,ii,jj-1)         
+         enddo
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(2:2,2:0,0:2,2:2))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj)=
+     *   A(i+2,j,ii,jj)+ A(i,j,ii+2,jj)+
+     *   A(i,j,ii,jj+2)+ A(i-2,j,ii,jj)+
+     *   A(i,j-2,ii,jj)+ A(i,j,ii,jj-2)+
+     *   A(i+1,j,ii,jj)+ A(i,j,ii+1,jj)+
+     *   A(i,j,ii,jj+1)+ A(i-1,j,ii,jj)+
+     *   A(i,j-1,ii,jj)+ A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end  
+C --------------------------------------------ACR4106  
+      subroutine ACR4106
+      integer, parameter :: N = 32,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(BLOCK,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(3:3,3:3,3:3,3:3) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4106'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=4,N-3
+       do j=4,M-3
+        do ii=4,K-3
+         do jj=4,L-3
+          C(i,j,ii,jj) =
+     *   C(i+3,j,ii,jj)+ C(i,j+3,ii,jj)+
+     *   C(i,j,ii+3,jj)+ C(i,j,ii,jj+3)+
+     *   C(i-3,j,ii,jj)+ C(i,j-3,ii,jj)+
+     *   C(i,j,ii-3,jj)+ C(i,j,ii,jj-3)+
+     *   C(i+2,j,ii,jj)+ C(i,j+2,ii,jj)+
+     *   C(i,j,ii+2,jj)+ C(i,j,ii,jj+2)+
+     *   C(i-2,j,ii,jj)+ C(i,j-2,ii,jj)+
+     *   C(i,j,ii-2,jj)+ C(i,j,ii,jj-2)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+1)+
+     *   C(i-1,j,ii,jj)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii-1,jj)+ C(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(3:3,3:3,3:3,3:3))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii,jj) =
+     *   A(i+3,j,ii,jj)+ A(i,j+3,ii,jj)+
+     *   A(i,j,ii+3,jj)+ A(i,j,ii,jj+3)+
+     *   A(i-3,j,ii,jj)+ A(i,j-3,ii,jj)+
+     *   A(i,j,ii-3,jj)+ A(i,j,ii,jj-3)+
+     *   A(i+2,j,ii,jj)+ A(i,j+2,ii,jj)+
+     *   A(i,j,ii+2,jj)+ A(i,j,ii,jj+2)+
+     *   A(i-2,j,ii,jj)+ A(i,j-2,ii,jj)+
+     *   A(i,j,ii-2,jj)+ A(i,j,ii,jj-2)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj+1)+
+     *   A(i-1,j,ii,jj)+ A(i,j-1,ii,jj)+
+     *   A(i,j,ii-1,jj)+ A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end 
+C -------------------------------------------ACR4107   
+      subroutine ACR4107
+      integer, parameter :: N = 16,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(BLOCK,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(0:3,3:3,0:3,0:3) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4107'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=4,N-3
+       do j=4,M-3
+        do ii=4,K-3
+         do jj=4,L-3
+          C(i,j,ii,jj) =
+     *   C(i+3,j,ii,jj)+ C(i,j+3,ii,jj)+
+     *   C(i,j,ii+3,jj)+ C(i,j,ii,jj+3)+ 
+     *   C(i,j-3,ii,jj)+ C(i+2,j,ii,jj)+
+     *   C(i,j+2,ii,jj)+ C(i,j,ii+2,jj)+
+     *   C(i,j,ii,jj+2)+ C(i,j-2,ii,jj)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+1)+ 
+     *   C(i,j-1,ii,jj)
+         enddo
+        enddo 
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region  
+
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(0:3,3:3,0:3,0:3))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii,jj) =
+     *   A(i+3,j,ii,jj)+ A(i,j+3,ii,jj)+
+     *   A(i,j,ii+3,jj)+ A(i,j,ii,jj+3)+ 
+     *   A(i,j-3,ii,jj)+ A(i+2,j,ii,jj)+
+     *   A(i,j+2,ii,jj)+ A(i,j,ii+2,jj)+
+     *   A(i,j,ii,jj+2)+ A(i,j-2,ii,jj)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj+1)+ 
+     *   A(i,j-1,ii,jj)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end   
+C -------------------------------------------ACR4108   
+      subroutine ACR4108
+      integer, parameter :: N = 16,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(BLOCK,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(0:3,3:3,0:3,3:0) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4108'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=4,N-3
+       do j=4,M-3
+        do ii=4,K-3
+         do jj=4,L-3
+          C(i,j,ii,jj) = 
+     *   C(i+3,j,ii,jj)+ C(i,j+3,ii,jj)+
+     *   C(i,j,ii+3,jj)+ C(i,j,ii,jj-3)+
+     *   C(i+2,j,ii,jj)+ C(i,j+2,ii,jj)+
+     *   C(i,j,ii+2,jj)+ C(i,j,ii,jj-2)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(0:3,0:3,0:3,3:0))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii,jj) = 
+     *   A(i+3,j,ii,jj)+ A(i,j+3,ii,jj)+
+     *   A(i,j,ii+3,jj)+ A(i,j,ii,jj-3)+
+     *   A(i+2,j,ii,jj)+ A(i,j+2,ii,jj)+
+     *   A(i,j,ii+2,jj)+ A(i,j,ii,jj-2)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end   
+C -------------------------------------------ACR4109   
+      subroutine ACR4109
+      integer, parameter :: N = 48,M=48,K=48,L=48, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(BLOCK,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(11:11,11:11,11:11,11:11) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4109'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=12,N-11
+       do j=12,M-11
+        do ii=12,K-11
+         do jj=12,L-11
+          C(i,j,ii,jj) =
+     *   C(i+11,j,ii,jj)+ C(i,j+11,ii,jj)+
+     *   C(i,j,ii+11,jj)+ C(i,j,ii,jj+11)+
+     *   C(i-11,j,ii,jj)+ C(i,j-11,ii,jj)+
+     *   C(i,j,ii-11,jj)+ C(i,j,ii,jj-11)
+         enddo
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(11:11,11:11,11:11,11:11))
+      do jj=12,L-11
+       do ii=12,K-11
+        do j=12,M-11
+         do i=12,N-11
+          A(i,j,ii,jj) =
+     *   A(i+11,j,ii,jj)+ A(i,j+11,ii,jj)+
+     *   A(i,j,ii+11,jj)+ A(i,j,ii,jj+11)+
+     *   A(i-11,j,ii,jj)+ A(i,j-11,ii,jj)+
+     *   A(i,j,ii-11,jj)+ A(i,j,ii,jj-11)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=12,L-11
+       do ii=12,K-11
+        do j=12,M-11
+         do i=12,N-11
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate ( A, B, C)
+      end    
+C -----------------------------------------------         
+      subroutine serial4(AR,N,M,K,L,NL)
+      integer AR(N,M,K,L)
+      integer NL 
+      do i=1,N
+       do j=1,M
+        do ii=1,K
+         do jj=1,L
+          AR(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo                 
+      end 
+
+      subroutine ansyes(name)
+      character*7 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*7 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/acr42.fdv

@@ -0,0 +1,881 @@
+      program ACR42
+
+c    TESTING OF THE ACROSS CLAUSE'.       
+c    DISTRIBUTED ARRAY A(N,M,K,L) IS TO HAVE DIFFERENT 
+c    FLOW-DEP-LENGTH ON BOTH SIDES      
+
+      print *,'===START OF ACR42========================'
+C --------------------------------------------------
+      call acr4201
+C --------------------------------------------------
+      call acr4202
+C --------------------------------------------------
+      call acr4203
+C -------------------------------------------------
+      call acr4204
+C -------------------------------------------------
+      call acr4205
+C -------------------------------------------------
+      call acr4206
+C --------------------------------------------------
+      call acr4207
+C --------------------------------------------------
+      call acr4208
+C----------------------------------------------------
+      call acr4209
+C----------------------------------------------------
+
+C
+C
+      print *,'=== END OF ACR42 ========================= '    
+      end
+C ---------------------------------------------ACR4201 
+      subroutine ACR4201    
+      integer, parameter :: N = 16,M=8,K=8,L=8, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,*,*,*)      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4201'     
+      allocate (B(N,M,K,L),A(N,M,K,L),C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=2,N-1
+       do j=2,M-1
+         do ii=2,K-1
+          do jj=2,L-1
+           C(i,j,ii,jj)=
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+1)+
+     *   C(i-1,j,ii,jj)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii-1,jj)+ C(i,j,ii,jj-1)
+         enddo 
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+        do ii=1,K
+         do j=1,M
+          do i=1,N
+           A(i,j,ii,jj) = NL+i+j+ii+jj
+          enddo
+         enddo
+        enddo
+       enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*across(A(1:1,1:1,1:1,1:1))
+      do jj=2,L-1
+       do ii=2,K-1
+        do j=2,M-1
+         do i=2,N-1
+          A(i,j,ii,jj)=
+     *   A(i+1,j,ii,jj)+A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+A(i,j,ii,jj+1)+
+     *   A(i-1,j,ii,jj)+A(i,j-1,ii,jj)+
+     *   A(i,j,ii-1,jj)+A(i,j,ii,jj-1)
+         enddo 
+        enddo
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=2,L-1
+       do ii=2,K-1
+        do j=2,M-1
+         do i=2,N-1         
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+           endif
+         enddo
+        enddo
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end
+C ---------------------------------------------ACR4202     
+      subroutine ACR4202    
+      integer, parameter :: N = 16,M=8,K=8,L=8, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,*,*,*)   
+!dvm$ shadow(2:2,2:2,2:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4202'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj) =
+     *   C(i+2,j,ii,jj)+ C(i,j+2,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+2)+
+     *   C(i-1,j,ii,jj)+ C(i,j-2,ii,jj)+
+     *   C(i,j,ii-2,jj)+ C(i,j,ii,jj-1)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii,jj+1)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo 
+      enddo 
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A) 
+
+!dvm$ parallel (i,j,ii,jj) on A(i,j,ii,jj)
+      do i=1,N
+       do j=1,M
+        do ii=1,K
+         do jj=1,L
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo 
+!dvm$ parallel (i,j,ii,jj) on A(i,j,ii,jj),across(A(1:2,2:2,2:1,1:2))
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          A(i,j,ii,jj) =
+     *   A(i+2,j,ii,jj)+ A(i,j+2,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj+2)+
+     *   A(i-1,j,ii,jj)+ A(i,j-2,ii,jj)+
+     *   A(i,j,ii-2,jj)+ A(i,j,ii,jj-1)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii,jj+1)+ A(i,j-1,ii,jj)+
+     *   A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (i,j,ii,jj) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end
+C -----------------------------------------ACR4203      
+      subroutine ACR4203     
+      integer, parameter :: N = 16,M=8,K=8,L=8, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,*,*,*)   
+!dvm$ shadow(2:2,2:2,2:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4203'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj) =  C(i-2,j,ii,jj)+
+     *   C(i,j-2,ii,jj)+ C(i,j,ii-2,jj)+
+     *   C(i,j,ii,jj-2)+ C(i-1,j,ii,jj)+
+     *   C(i,j-1,ii,jj)+ C(i,j,ii-1,jj)+
+     *   C(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo  
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out( A) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(2:0,2:2,2:0,2:0))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj) =  A(i-2,j,ii,jj)+
+     *   A(i,j-2,ii,jj)+ A(i,j,ii-2,jj)+
+     *   A(i,j,ii,jj-2)+ A(i-1,j,ii,jj)+
+     *   A(i,j-1,ii,jj)+ A(i,j,ii-1,jj)+
+     *   A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then         
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end 
+C ------------------------------------------ACR4204   
+      subroutine ACR4204     
+      integer, parameter :: N = 16,M=8,K=8,L=8, NL=1000            
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,*,*,*)   
+!dvm$ shadow(2:2,2:2,2:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4204'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj) =  C(i+2,j,ii,jj)+
+     *   C(i,j,ii,jj+2)+ C(i-2,j,ii,jj)+
+     *   C(i,j-2,ii,jj)+ C(i,j,ii-2,jj)+
+     *   C(i+1,j,ii,jj)+ C(i,j,ii,jj+1)+
+     *   C(i-1,j,ii,jj)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii-1,jj)
+         enddo
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(2:2,2:0,2:0,0:2))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj) =  A(i+2,j,ii,jj)+
+     *   A(i,j,ii,jj+2)+ A(i-2,j,ii,jj)+
+     *   A(i,j-2,ii,jj)+ A(i,j,ii-2,jj)+
+     *   A(i+1,j,ii,jj)+ A(i,j,ii,jj+1)+
+     *   A(i-1,j,ii,jj)+ A(i,j-1,ii,jj)+
+     *   A(i,j,ii-1,jj)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end  
+C ------------------------------------------ACR4205
+      subroutine ACR4205
+      integer, parameter :: N = 16,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,*,*,*)   
+!dvm$ shadow(2:2,2:0,0:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4205'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj)=
+     *   C(i+2,j,ii,jj)+ C(i,j,ii+2,jj)+
+     *   C(i,j,ii,jj+2)+ C(i-2,j,ii,jj)+
+     *   C(i,j-2,ii,jj)+ C(i,j,ii,jj-2)+
+     *   C(i+1,j,ii,jj)+ C(i,j,ii+1,jj)+
+     *   C(i,j,ii,jj+1)+ C(i-1,j,ii,jj)+
+     *   C(i,j-1,ii,jj)+ C(i,j,ii,jj-1)         
+         enddo
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(2:2,2:0,0:2,2:2))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj)=
+     *   A(i+2,j,ii,jj)+ A(i,j,ii+2,jj)+
+     *   A(i,j,ii,jj+2)+ A(i-2,j,ii,jj)+
+     *   A(i,j-2,ii,jj)+ A(i,j,ii,jj-2)+
+     *   A(i+1,j,ii,jj)+ A(i,j,ii+1,jj)+
+     *   A(i,j,ii,jj+1)+ A(i-1,j,ii,jj)+
+     *   A(i,j-1,ii,jj)+ A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end  
+C --------------------------------------------ACR4206  
+      subroutine ACR4206
+      integer, parameter :: N = 32,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,*,*,*)   
+!dvm$ shadow(3:3,3:3,3:3,3:3) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4206'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=4,N-3
+       do j=4,M-3
+        do ii=4,K-3
+         do jj=4,L-3
+          C(i,j,ii,jj) =
+     *   C(i+3,j,ii,jj)+ C(i,j+3,ii,jj)+
+     *   C(i,j,ii+3,jj)+ C(i,j,ii,jj+3)+
+     *   C(i-3,j,ii,jj)+ C(i,j-3,ii,jj)+
+     *   C(i,j,ii-3,jj)+ C(i,j,ii,jj-3)+
+     *   C(i+2,j,ii,jj)+ C(i,j+2,ii,jj)+
+     *   C(i,j,ii+2,jj)+ C(i,j,ii,jj+2)+
+     *   C(i-2,j,ii,jj)+ C(i,j-2,ii,jj)+
+     *   C(i,j,ii-2,jj)+ C(i,j,ii,jj-2)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+1)+
+     *   C(i-1,j,ii,jj)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii-1,jj)+ C(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(3:3,3:3,3:3,3:3))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii,jj) =
+     *   A(i+3,j,ii,jj)+ A(i,j+3,ii,jj)+
+     *   A(i,j,ii+3,jj)+ A(i,j,ii,jj+3)+
+     *   A(i-3,j,ii,jj)+ A(i,j-3,ii,jj)+
+     *   A(i,j,ii-3,jj)+ A(i,j,ii,jj-3)+
+     *   A(i+2,j,ii,jj)+ A(i,j+2,ii,jj)+
+     *   A(i,j,ii+2,jj)+ A(i,j,ii,jj+2)+
+     *   A(i-2,j,ii,jj)+ A(i,j-2,ii,jj)+
+     *   A(i,j,ii-2,jj)+ A(i,j,ii,jj-2)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj+1)+
+     *   A(i-1,j,ii,jj)+ A(i,j-1,ii,jj)+
+     *   A(i,j,ii-1,jj)+ A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end 
+C -------------------------------------------ACR4207   
+      subroutine ACR4207
+      integer, parameter :: N = 16,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,*,*,*)   
+!dvm$ shadow(0:3,3:3,0:3,0:3) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4207'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=4,N-3
+       do j=4,M-3
+        do ii=4,K-3
+         do jj=4,L-3
+          C(i,j,ii,jj) =
+     *   C(i+3,j,ii,jj)+ C(i,j+3,ii,jj)+
+     *   C(i,j,ii+3,jj)+ C(i,j,ii,jj+3)+ 
+     *   C(i,j-3,ii,jj)+ C(i+2,j,ii,jj)+
+     *   C(i,j+2,ii,jj)+ C(i,j,ii+2,jj)+
+     *   C(i,j,ii,jj+2)+ C(i,j-2,ii,jj)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+1)+ 
+     *   C(i,j-1,ii,jj)
+         enddo
+        enddo 
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(0:3,3:3,0:3,0:3))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii,jj) =
+     *   A(i+3,j,ii,jj)+ A(i,j+3,ii,jj)+
+     *   A(i,j,ii+3,jj)+ A(i,j,ii,jj+3)+ 
+     *   A(i,j-3,ii,jj)+ A(i+2,j,ii,jj)+
+     *   A(i,j+2,ii,jj)+ A(i,j,ii+2,jj)+
+     *   A(i,j,ii,jj+2)+ A(i,j-2,ii,jj)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj+1)+ 
+     *   A(i,j-1,ii,jj)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end   
+C -------------------------------------------ACR4208   
+      subroutine ACR4208
+      integer, parameter :: N = 16,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,*,*,*)   
+!dvm$ shadow(0:3,3:3,0:3,3:0) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4208'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=4,N-3
+       do j=4,M-3
+        do ii=4,K-3
+         do jj=4,L-3
+          C(i,j,ii,jj) = 
+     *   C(i+3,j,ii,jj)+ C(i,j+3,ii,jj)+
+     *   C(i,j,ii+3,jj)+ C(i,j,ii,jj-3)+
+     *   C(i+2,j,ii,jj)+ C(i,j+2,ii,jj)+
+     *   C(i,j,ii+2,jj)+ C(i,j,ii,jj-2)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(0:3,0:3,0:3,3:0))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii,jj) = 
+     *   A(i+3,j,ii,jj)+ A(i,j+3,ii,jj)+
+     *   A(i,j,ii+3,jj)+ A(i,j,ii,jj-3)+
+     *   A(i+2,j,ii,jj)+ A(i,j+2,ii,jj)+
+     *   A(i,j,ii+2,jj)+ A(i,j,ii,jj-2)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end   
+C -------------------------------------------ACR4209   
+      subroutine ACR4209
+      integer, parameter :: N = 48,M=48,K=48,L=48, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,*,*,*)   
+!dvm$ shadow(11:11,11:11,11:11,11:11) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4209'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=12,N-11
+       do j=12,M-11
+        do ii=12,K-11
+         do jj=12,L-11
+          C(i,j,ii,jj) =
+     *   C(i+11,j,ii,jj)+ C(i,j+11,ii,jj)+
+     *   C(i,j,ii+11,jj)+ C(i,j,ii,jj+11)+
+     *   C(i-11,j,ii,jj)+ C(i,j-11,ii,jj)+
+     *   C(i,j,ii-11,jj)+ C(i,j,ii,jj-11)
+         enddo
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region  
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(11:11,11:11,11:11,11:11))
+      do jj=12,L-11
+       do ii=12,K-11
+        do j=12,M-11
+         do i=12,N-11
+          A(i,j,ii,jj) =
+     *   A(i+11,j,ii,jj)+ A(i,j+11,ii,jj)+
+     *   A(i,j,ii+11,jj)+ A(i,j,ii,jj+11)+
+     *   A(i-11,j,ii,jj)+ A(i,j-11,ii,jj)+
+     *   A(i,j,ii-11,jj)+ A(i,j,ii,jj-11)
+         enddo
+        enddo 
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=12,L-11
+       do ii=12,K-11
+        do j=12,M-11
+         do i=12,N-11
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end    
+C -----------------------------------------------         
+      subroutine serial4(AR,N,M,K,L,NL)
+      integer AR(N,M,K,L)
+      integer NL 
+      do i=1,N
+       do j=1,M
+        do ii=1,K
+         do jj=1,L
+          AR(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo                 
+      end 
+
+      subroutine ansyes(name)
+      character*7 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*7 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/acr43.fdv

@@ -0,0 +1,883 @@
+      program ACR43
+
+c    TESTING OF THE ACROSS CLAUSE'.       
+c    DISTRIBUTED ARRAY A(N,M,K,L) IS TO HAVE DIFFERENT 
+c    FLOW-DEP-LENGTH ON BOTH SIDES      
+
+      print *,'===START OF ACR43========================'
+C --------------------------------------------------
+      call acr4301
+C --------------------------------------------------
+      call acr4302
+C --------------------------------------------------
+      call acr4303
+C -------------------------------------------------
+      call acr4304
+C -------------------------------------------------
+      call acr4305
+C -------------------------------------------------
+      call acr4306
+C --------------------------------------------------
+      call acr4307
+C --------------------------------------------------
+      call acr4308
+C----------------------------------------------------
+       call acr4309
+C----------------------------------------------------
+
+C
+C
+      print *,'=== END OF ACR43 ========================= '    
+      end
+C ---------------------------------------------ACR4301 
+      subroutine ACR4301    
+      integer, parameter :: N = 16,M=8,K=8,L=8, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,BLOCK,BLOCK,BLOCK)      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4301'     
+      allocate (B(N,M,K,L),A(N,M,K,L),C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=2,N-1
+       do j=2,M-1
+         do ii=2,K-1
+          do jj=2,L-1
+           C(i,j,ii,jj)=
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+1)+
+     *   C(i-1,j,ii,jj)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii-1,jj)+ C(i,j,ii,jj-1)
+         enddo 
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+        do ii=1,K
+         do j=1,M
+          do i=1,N
+           A(i,j,ii,jj) = NL+i+j+ii+jj
+          enddo
+         enddo
+        enddo
+       enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*across(A(1:1,1:1,1:1,1:1))
+      do jj=2,L-1
+       do ii=2,K-1
+        do j=2,M-1
+         do i=2,N-1
+          A(i,j,ii,jj)=
+     *   A(i+1,j,ii,jj)+A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+A(i,j,ii,jj+1)+
+     *   A(i-1,j,ii,jj)+A(i,j-1,ii,jj)+
+     *   A(i,j,ii-1,jj)+A(i,j,ii,jj-1)
+         enddo 
+        enddo
+       enddo 
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=2,L-1
+       do ii=2,K-1
+        do j=2,M-1
+         do i=2,N-1
+            if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+           endif
+         enddo
+        enddo
+       enddo
+      enddo
+!dvm$ end region
+!dvm$ get_actual(nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end
+C ---------------------------------------------ACR4302     
+      subroutine ACR4302    
+      integer, parameter :: N = 16,M=10,K=10,L=10, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,BLOCK,BLOCK,BLOCK)
+!dvm$ shadow(2:2,2:2,2:2,2:2) :: A 
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4302'
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj) =
+     *   C(i+2,j,ii,jj)+ C(i,j+2,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+2)+
+     *   C(i-1,j,ii,jj)+ C(i,j-2,ii,jj)+
+     *   C(i,j,ii-2,jj)+ C(i,j,ii,jj-1)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii,jj+1)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo 
+      enddo 
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in( C),out( A) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),across(A(1:2,2:2,2:1,1:2))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj) =
+     *   A(i+2,j,ii,jj)+ A(i,j+2,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj+2)+
+     *   A(i-1,j,ii,jj)+ A(i,j-2,ii,jj)+
+     *   A(i,j,ii-2,jj)+ A(i,j,ii,jj-1)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii,jj+1)+ A(i,j-1,ii,jj)+
+     *   A(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end
+C -----------------------------------------ACR4303      
+      subroutine ACR4303     
+      integer, parameter :: N = 16,M=10,K=10,L=10, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,BLOCK,BLOCK,BLOCK)
+!dvm$ shadow(2:2,2:2,2:2,2:2) :: A
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4303'
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj) =  C(i-2,j,ii,jj)+
+     *   C(i,j-2,ii,jj)+ C(i,j,ii-2,jj)+
+     *   C(i,j,ii,jj-2)+ C(i-1,j,ii,jj)+
+     *   C(i,j-1,ii,jj)+ C(i,j,ii-1,jj)+
+     *   C(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo 
+      enddo  
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C)
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(2:0,2:2,2:0,2:0))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj) =  A(i-2,j,ii,jj)+
+     *   A(i,j-2,ii,jj)+ A(i,j,ii-2,jj)+
+     *   A(i,j,ii,jj-2)+ A(i-1,j,ii,jj)+
+     *   A(i,j-1,ii,jj)+ A(i,j,ii-1,jj)+
+     *   A(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end 
+C ------------------------------------------ACR4304   
+      subroutine ACR4304     
+      integer, parameter :: N = 16,M=10,K=10,L=10, NL=1000            
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:2,2:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4304'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj) =  C(i+2,j,ii,jj)+
+     *   C(i,j,ii,jj+2)+ C(i-2,j,ii,jj)+
+     *   C(i,j-2,ii,jj)+ C(i,j,ii-2,jj)+
+     *   C(i+1,j,ii,jj)+ C(i,j,ii,jj+1)+
+     *   C(i-1,j,ii,jj)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii-1,jj)
+         enddo
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C)
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(2:2,2:0,2:0,0:2))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj) =  A(i+2,j,ii,jj)+
+     *   A(i,j,ii,jj+2)+ A(i-2,j,ii,jj)+
+     *   A(i,j-2,ii,jj)+ A(i,j,ii-2,jj)+
+     *   A(i+1,j,ii,jj)+ A(i,j,ii,jj+1)+
+     *   A(i-1,j,ii,jj)+ A(i,j-1,ii,jj)+
+     *   A(i,j,ii-1,jj)
+         enddo
+        enddo
+       enddo
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end
+C ------------------------------------------ACR4305
+      subroutine ACR4305
+      integer, parameter :: N = 16,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(2:2,2:0,0:2,2:2) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4305'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=3,N-2
+       do j=3,M-2
+        do ii=3,K-2
+         do jj=3,L-2
+          C(i,j,ii,jj)=
+     *   C(i+2,j,ii,jj)+ C(i,j,ii+2,jj)+
+     *   C(i,j,ii,jj+2)+ C(i-2,j,ii,jj)+
+     *   C(i,j-2,ii,jj)+ C(i,j,ii,jj-2)+
+     *   C(i+1,j,ii,jj)+ C(i,j,ii+1,jj)+
+     *   C(i,j,ii,jj+1)+ C(i-1,j,ii,jj)+
+     *   C(i,j-1,ii,jj)+ C(i,j,ii,jj-1)         
+         enddo
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A)
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(2:2,2:0,0:2,2:2))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          A(i,j,ii,jj)=
+     *   A(i+2,j,ii,jj)+ A(i,j,ii+2,jj)+
+     *   A(i,j,ii,jj+2)+ A(i-2,j,ii,jj)+
+     *   A(i,j-2,ii,jj)+ A(i,j,ii,jj-2)+
+     *   A(i+1,j,ii,jj)+ A(i,j,ii+1,jj)+
+     *   A(i,j,ii,jj+1)+ A(i-1,j,ii,jj)+
+     *   A(i,j-1,ii,jj)+ A(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=3,L-2
+       do ii=3,K-2
+        do j=3,M-2
+         do i=3,N-2
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end  
+C --------------------------------------------ACR4306  
+      subroutine ACR4306
+      integer, parameter :: N = 32,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(3:3,3:3,3:3,3:3) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4306'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=4,N-3
+       do j=4,M-3
+        do ii=4,K-3
+         do jj=4,L-3
+          C(i,j,ii,jj) =
+     *   C(i+3,j,ii,jj)+ C(i,j+3,ii,jj)+
+     *   C(i,j,ii+3,jj)+ C(i,j,ii,jj+3)+
+     *   C(i-3,j,ii,jj)+ C(i,j-3,ii,jj)+
+     *   C(i,j,ii-3,jj)+ C(i,j,ii,jj-3)+
+     *   C(i+2,j,ii,jj)+ C(i,j+2,ii,jj)+
+     *   C(i,j,ii+2,jj)+ C(i,j,ii,jj+2)+
+     *   C(i-2,j,ii,jj)+ C(i,j-2,ii,jj)+
+     *   C(i,j,ii-2,jj)+ C(i,j,ii,jj-2)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+1)+
+     *   C(i-1,j,ii,jj)+ C(i,j-1,ii,jj)+
+     *   C(i,j,ii-1,jj)+ C(i,j,ii,jj-1)
+         enddo
+        enddo 
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C) 
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(3:3,3:3,3:3,3:3))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii,jj) =
+     *   A(i+3,j,ii,jj)+ A(i,j+3,ii,jj)+
+     *   A(i,j,ii+3,jj)+ A(i,j,ii,jj+3)+
+     *   A(i-3,j,ii,jj)+ A(i,j-3,ii,jj)+
+     *   A(i,j,ii-3,jj)+ A(i,j,ii,jj-3)+
+     *   A(i+2,j,ii,jj)+ A(i,j+2,ii,jj)+
+     *   A(i,j,ii+2,jj)+ A(i,j,ii,jj+2)+
+     *   A(i-2,j,ii,jj)+ A(i,j-2,ii,jj)+
+     *   A(i,j,ii-2,jj)+ A(i,j,ii,jj-2)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj+1)+
+     *   A(i-1,j,ii,jj)+ A(i,j-1,ii,jj)+
+     *   A(i,j,ii-1,jj)+ A(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end 
+C -------------------------------------------ACR4307   
+      subroutine ACR4307
+      integer, parameter :: N = 16,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(0:3,3:3,0:3,0:3) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4307'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=4,N-3
+       do j=4,M-3
+        do ii=4,K-3
+         do jj=4,L-3
+          C(i,j,ii,jj) =
+     *   C(i+3,j,ii,jj)+ C(i,j+3,ii,jj)+
+     *   C(i,j,ii+3,jj)+ C(i,j,ii,jj+3)+ 
+     *   C(i,j-3,ii,jj)+ C(i+2,j,ii,jj)+
+     *   C(i,j+2,ii,jj)+ C(i,j,ii+2,jj)+
+     *   C(i,j,ii,jj+2)+ C(i,j-2,ii,jj)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj+1)+ 
+     *   C(i,j-1,ii,jj)
+         enddo
+        enddo
+       enddo
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C),out (A)
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(0:3,3:3,0:3,0:3))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii,jj) =
+     *   A(i+3,j,ii,jj)+ A(i,j+3,ii,jj)+
+     *   A(i,j,ii+3,jj)+ A(i,j,ii,jj+3)+ 
+     *   A(i,j-3,ii,jj)+ A(i+2,j,ii,jj)+
+     *   A(i,j+2,ii,jj)+ A(i,j,ii+2,jj)+
+     *   A(i,j,ii,jj+2)+ A(i,j-2,ii,jj)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj+1)+ 
+     *   A(i,j-1,ii,jj)
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ parallel (jj,ii,j,i) on B(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end
+C -------------------------------------------ACR4308   
+      subroutine ACR4308
+      integer, parameter :: N = 16,M=16,K=16,L=16, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(0:3,3:3,0:3,3:0) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4308'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=4,N-3
+       do j=4,M-3
+        do ii=4,K-3
+         do jj=4,L-3
+          C(i,j,ii,jj) = 
+     *   C(i+3,j,ii,jj)+ C(i,j+3,ii,jj)+
+     *   C(i,j,ii+3,jj)+ C(i,j,ii,jj-3)+
+     *   C(i+2,j,ii,jj)+ C(i,j+2,ii,jj)+
+     *   C(i,j,ii+2,jj)+ C(i,j,ii,jj-2)+
+     *   C(i+1,j,ii,jj)+ C(i,j+1,ii,jj)+
+     *   C(i,j,ii+1,jj)+ C(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C)
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(0:3,0:3,0:3,3:0))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          A(i,j,ii,jj) = 
+     *   A(i+3,j,ii,jj)+ A(i,j+3,ii,jj)+
+     *   A(i,j,ii+3,jj)+ A(i,j,ii,jj-3)+
+     *   A(i+2,j,ii,jj)+ A(i,j+2,ii,jj)+
+     *   A(i,j,ii+2,jj)+ A(i,j,ii,jj-2)+
+     *   A(i+1,j,ii,jj)+ A(i,j+1,ii,jj)+
+     *   A(i,j,ii+1,jj)+ A(i,j,ii,jj-1)
+         enddo
+        enddo
+       enddo
+      enddo
+  
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=4,L-3
+       do ii=4,K-3
+        do j=4,M-3
+         do i=4,N-3
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end
+C -------------------------------------------ACR4309   
+      subroutine ACR4309
+      integer, parameter :: N = 58,M=58,K=58,L=58, NL=1000
+      integer, allocatable :: A(:,:,:,:), B(:,:,:,:), C(:,:,:,:)
+      integer nloopi,nloopj,nloopii,nloopjj
+      character*7 tname 
+!dvm$ distribute B(*,BLOCK,BLOCK,BLOCK)   
+!dvm$ shadow(11:11,11:11,11:11,11:11) :: A      
+!dvm$ align (i,j,ii,jj) with B(i,j,ii,jj) ::A
+      tname='ACR4309'     
+      allocate (B(N,M,K,L), A(N,M,K,L), C(N,M,K,L))
+      NNL=NL    
+      call serial4(C,N,M,K,L,NNL)
+      do i=12,N-11
+       do j=12,M-11
+        do ii=12,K-11
+         do jj=12,L-11
+          C(i,j,ii,jj) =
+     *   C(i+11,j,ii,jj)+ C(i,j+11,ii,jj)+
+     *   C(i,j,ii+11,jj)+ C(i,j,ii,jj+11)+
+     *   C(i-11,j,ii,jj)+ C(i,j-11,ii,jj)+
+     *   C(i,j,ii-11,jj)+ C(i,j,ii,jj-11)
+         enddo
+        enddo
+       enddo 
+      enddo
+      nloopi=NL
+      nloopj=NL
+      nloopii=NL
+      nloopjj=NL
+
+!dvm$ actual (nloopi,nloopj,nloopii,nloopjj,C)
+!dvm$ region in (C)
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj)
+      do jj=1,L
+       do ii=1,K
+        do j=1,M
+         do i=1,N
+          A(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+ 
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*across(A(11:11,11:11,11:11,11:11))
+      do jj=12,L-11
+       do ii=12,K-11
+        do j=12,M-11
+         do i=12,N-11
+          A(i,j,ii,jj) =
+     *   A(i+11,j,ii,jj)+ A(i,j+11,ii,jj)+
+     *   A(i,j,ii+11,jj)+ A(i,j,ii,jj+11)+
+     *   A(i-11,j,ii,jj)+ A(i,j-11,ii,jj)+
+     *   A(i,j,ii-11,jj)+ A(i,j,ii,jj-11)
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ parallel (jj,ii,j,i) on A(i,j,ii,jj),
+!dvm$*reduction( min( nloopi),min(nloopj),min(nloopii),min(nloopjj))
+      do jj=12,L-11
+       do ii=12,K-11
+        do j=12,M-11
+         do i=12,N-11
+          if (A(i,j,ii,jj).ne.C(i,j,ii,jj)) then
+           nloopi=min(nloopi,i)
+           nloopj=min(nloopj,j)
+           nloopii=min(nloopii,ii)
+           nloopjj=min(nloopjj,jj)
+          endif
+         enddo
+        enddo
+       enddo
+      enddo
+
+!dvm$ end region
+!dvm$ get_actual (nloopi)
+
+      if (nloopi .eq.NL) then
+       call ansyes(tname)
+      else
+       call ansno(tname)
+      endif
+      deallocate (A, B, C)
+      end
+C -----------------------------------------------         
+      subroutine serial4(AR,N,M,K,L,NL)
+      integer AR(N,M,K,L)
+      integer NL
+      do i=1,N
+       do j=1,M
+        do ii=1,K
+         do jj=1,L
+          AR(i,j,ii,jj) = NL+i+j+ii+jj
+         enddo
+        enddo
+       enddo
+      enddo
+      end
+
+      subroutine ansyes(name)
+      character*7 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*7 name
+      print *,name,'  -  ***error'
+      end
+      

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ACROSS/settings

@@ -0,0 +1 @@
+ALLOW_MULTIDEV=0

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ALIGN/align11.fdv

@@ -0,0 +1,441 @@
+      program ALIGN11
+
+c    TESTING align CLAUSE .       
+
+      print *,'===START OF align11========================'
+C --------------------------------------------------
+c 111 arrA1[BLOCK]  arrB1[ ]  ALIGN arrB[i] WITH arrA[i]  normal 
+      call align111
+C --------------------------------------------------
+c 1111  arrA1[BLOCK]  arrB1[ ]  ALIGN arrB[i] WITH arrA[i]  small array 
+      call align1111
+C --------------------------------------------------
+c 1112  arrA1[BLOCK]  arrB1[ ]  ALIGN arrB[i] WITH arrA[2*i+1]  small array 
+      call align1112
+C --------------------------------------------------
+c 112                         ALIGN arrB[i] WITH arrA[i+4]  shift along i 
+      call align112
+C --------------------------------------------------
+c 113                         ALIGN arrB[i] WITH arrA[-i+9] reverse on i
+c      call align113
+C --------------------------------------------------
+c 114                         ALIGN arrB[i] WITH arrA[2*i+8]  stretching along i
+      call align114
+C --------------------------------------------------
+c 115                             ALIGN arrB[*] WITH arrA[*]   
+      call align115
+C --------------------------------------------------
+C
+C
+      print *,'=== END OF align11 ========================= '    
+      end
+
+C ----------------------------------------------------align111
+c 111 arrA1[BLOCK]  arrB1[ ]  ALIGN arrB[i] WITH arrA[i]  normal 
+      subroutine align111
+      integer, parameter :: AN1=8,BN1=8,PN = 4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]                                                 
+      integer, parameter :: k1i=1,k2i=0,li=0
+      character*9 tname
+      integer,allocatable :: A1(:),B1(:)
+      integer erri,i
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B1(i) WITH A1(k1i * i + li)
+
+      tname='align111'
+      allocate (A1(AN1),B1(BN1))
+      erri= ER
+c      call stralign111 
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A1,B1)
+!dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =0     
+      enddo 
+
+!dvm$ parallel (i) on A1(i), private(ib)
+      do i=1,AN1
+             A1(i) = i
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)) then
+                ib = (i-li)/k1i
+                B1(ib) = ib
+             endif 
+      enddo 
+
+!dvm$ parallel (i) on B1(i), reduction( min( erri ) ), private(ia)
+      do i=1,BN1
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif 
+            ia=k1i * i + li
+            if (A1(ia) .eq.(ia)) then     
+            else
+               erri = min(erri,i)
+            endif 
+      enddo 
+!dvm$ end region   
+!dvm$ get_actual(erri) 
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A1)
+      end
+C ----------------------------------------------------align1111
+c 1111  arrA1[BLOCK]  arrB1[ ]  ALIGN arrB[i] WITH arrA[i]  small array 
+      subroutine align1111
+      integer, parameter :: AN1=5,BN1=2,PN = 4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]                                                 
+      integer, parameter :: k1i=1,k2i=0,li=0
+      character*9 tname
+      integer,allocatable :: A1(:),B1(:)
+      integer erri,i
+               
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B1(i) WITH A1(k1i * i + li)
+
+      tname='align1111'
+      allocate (A1(AN1),B1(BN1))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A1,B1)
+!dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =0     
+      enddo 
+
+!dvm$ parallel (i) on A1(i), private(ib)
+      do i=1,AN1
+             A1(i) = i
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)) then
+                ib = (i-li)/k1i
+                B1(ib) = ib
+             endif 
+      enddo 
+
+!dvm$ parallel (i) on B1(i), reduction( min( erri ) ), private(ia)
+      do i=1,BN1
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif 
+            ia=k1i * i + li
+            if (A1(ia) .eq.(ia)) then     
+            else
+               erri = min(erri,i)
+            endif 
+      enddo 
+!dvm$ end region   
+!dvm$ get_actual(erri)   
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A1)
+
+      end
+C ----------------------------------------------------align1112
+c 1112  arrA1[BLOCK]  arrB1[ ]  ALIGN arrB[i] WITH arrA[2*i+1]  small array 
+      subroutine align1112
+      integer, parameter :: AN1=5,BN1=2,PN = 4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]                                                 
+      integer, parameter :: k1i=2,k2i=0,li=1
+      character*9 tname
+      integer,allocatable :: A1(:),B1(:)
+      integer erri,i
+               
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B1(i) WITH A1(k1i * i + li)
+
+      tname='align1112'
+      allocate (A1(AN1),B1(BN1))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A1,B1)
+!dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =0     
+      enddo 
+
+!dvm$ parallel (i) on A1(i), private(ib)
+      do i=1,AN1
+             A1(i) = i
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)) then
+                ib = (i-li)/k1i
+                B1(ib) = ib
+             endif 
+      enddo 
+
+!dvm$ parallel (i) on B1(i), reduction( min( erri ) ), private(ia)
+      do i=1,BN1
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif 
+            ia=k1i * i + li
+            if (A1(ia) .eq.(ia)) then     
+            else
+               erri = min(erri,i)
+            endif 
+      enddo 
+!dvm$ end region   
+!dvm$ get_actual(erri) 
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A1)
+
+      end
+C ----------------------------------------------------align112
+c 112                         ALIGN arrB[i] WITH arrA[i+4]  shift along i 
+      subroutine align112
+      integer, parameter :: AN1=8,BN1=4,PN = 4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]                                                 
+      integer, parameter :: k1i=1,k2i=0,li=4
+      character*9 tname
+      integer,allocatable :: A1(:),B1(:)
+      integer erri,i
+               
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B1(i) WITH A1(k1i * i + li)
+
+      tname='align112'
+      allocate (A1(AN1),B1(BN1))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A1,B1)
+!dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =0     
+      enddo 
+
+!dvm$ parallel (i) on A1(i), private(ib)
+      do i=1,AN1
+             A1(i) = i
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)) then
+                ib = (i-li)/k1i
+                B1(ib) = ib
+             endif 
+      enddo 
+
+!dvm$ parallel (i) on B1(i), reduction( min( erri ) ), private(ia)
+      do i=1,BN1
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif 
+            ia=k1i * i + li
+            if (A1(ia) .eq.(ia)) then     
+            else
+               erri = min(erri,i)
+            endif 
+      enddo 
+!dvm$ end region   
+!dvm$ get_actual(erri) 
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A1)
+
+      end
+C ----------------------------------------------------align113
+c 113     ALIGN arrB[i] WITH arrA[-i+9] reverse on i
+      subroutine align113
+      integer, parameter :: AN1=8,BN1=8,PN = 4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]                                                 
+      integer, parameter :: k1i=-1,k2i=0,li=9
+      character*9 tname
+      integer,allocatable :: A1(:),B1(:)
+      integer erri,i
+               
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B1(i) WITH A1(k1i * i + li)
+
+      tname='align113'
+      allocate (A1(AN1),B1(BN1))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A1,B1)
+!dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =0     
+      enddo 
+
+!dvm$ parallel (i) on A1(i), private(ib)
+      do i=1,AN1
+             A1(i) = i
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)) then
+                ib = (i-li)/k1i
+                B1(ib) = ib
+             endif 
+      enddo 
+
+!dvm$ parallel (i) on B1(i), reduction( min( erri ) ), private(ia)
+      do i=1,BN1
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif 
+            ia=k1i * i + li
+            if (A1(ia) .eq.(ia)) then     
+            else
+               erri = min(erri,i)
+            endif 
+      enddo 
+!dvm$ end region   
+!dvm$ get_actual(erri) 
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A1)
+
+      end
+C ----------------------------------------------------align114
+c 114     ALIGN arrB[i] WITH arrA[2*i+8]  stretching along i
+      subroutine align114
+      integer, parameter :: AN1=24,BN1=8,PN = 4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA[k1i * i + li]                                                 
+      integer, parameter :: k1i=2,k2i=0,li=8
+      character*9 tname
+      integer,allocatable :: A1(:),B1(:)
+      integer erri,i
+               
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B1(i) WITH A1(k1i * i + li)
+
+
+      tname='align114'
+      allocate (A1(AN1),B1(BN1))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A1,B1),inout(erri)
+!dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =0     
+      enddo 
+
+!dvm$ parallel (i) on A1(i), private(ib)
+      do i=1,AN1
+             A1(i) = i
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)) then
+                ib = (i-li)/k1i
+                B1(ib) = ib
+             endif 
+      enddo 
+
+!dvm$ parallel (i) on B1(i), reduction( min( erri ) ), private(ia)
+      do i=1,BN1
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif 
+            ia=k1i * i + li
+            if (A1(ia) .eq.(ia)) then     
+            else
+               erri = min(erri,i)
+            endif 
+      enddo 
+!dvm$ end region   
+!dvm$ get_actual(erri) 
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A1)
+
+      end
+C ----------------------------------------------------align115
+c 115                             ALIGN arrB[*] WITH arrA[*]   
+      subroutine align115
+      integer, parameter :: AN1=24,BN1=8,PN = 4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[*] WITH arrA[*]                                                 
+      integer, parameter :: k1i=0,k2i=0,li=0
+      character*9 tname
+      integer,allocatable :: A1(:),B1(:)
+      integer erri,i
+               
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B1(*) WITH A1(*)
+
+      tname='align115'
+      allocate (A1(AN1),B1(BN1))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A1,B1)
+!dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =i     
+      enddo 
+
+!dvm$ parallel (i) on A1(i), reduction( min( erri ) ),private(j)
+      do i=1,AN1
+        do j=1,BN1
+            if (B1(j) .eq.(j)) then     
+            else
+               erri = min(erri,j)
+            endif 
+        enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A1)
+
+      end
+C -------------------------------------------------
+
+      subroutine ansyes(name)
+      character*9 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*9 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ALIGN/align12.fdv

@@ -0,0 +1,233 @@
+      program ALIGN12
+
+c    TESTING align CLAUSE .       
+
+      print *,'===START OF align12========================'
+C --------------------------------------------------
+c 121	arrA1[BLOCK]	arrB2[][]	ALIGN arrB[][i] WITH arrA[i]	matrix compression: 
+c                                                              column on vector element
+      call align121
+C -------------------------------------------------
+c 122			                    ALIGN arrB[i][ ] WITH arrA[2*i+1]	matrix compression: 
+c                                                               line on vector element
+      call align122
+C -------------------------------------------------
+c 123			                    ALIGN arrB[][ ] WITH arrA[]	 
+      call align123
+C -------------------------------------------------
+C
+C
+      print *,'=== END OF align12 ========================= '    
+      end
+
+C ----------------------------------------------------align121
+c 121	arrA1[BLOCK]	arrB2[][]	ALIGN arrB[][i] WITH arrA[i]	matrix compression: 
+c                                                              column on vector element
+      subroutine align121
+      integer, parameter ::  AN1=8,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB(*,i) WITH arrA[k1i*i+li]                                                
+      integer, parameter ::  k1i=1,k2i=0,li=0
+      character*9 tname
+      integer, allocatable :: A1(:),B2(:,:)
+      integer s,cs,erri,i,j,ib,jb              
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B2(*,i) WITH A1(k1i*i+li)
+
+      tname='align121'
+      allocate (A1(AN1),B2(BN1,BN2))
+      erri= ER
+c      call stralign121 
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri, s)
+!dvm$ region local(A1,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo
+      enddo 
+
+!dvm$ parallel (i) on A1(i), private(ib,jb,j)
+      do i=1,AN1
+          A1(i) = i
+          do j=1,BN1
+             if (  
+     *          ((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN2)  )then
+                ib = j
+                jb = (i-li)/k1i
+                B2(ib,jb) = ib*NL+jb
+             endif   
+          enddo 
+      enddo 
+      
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+          do j=1,BN2
+            s = s + B2(i,j)
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+                cs = cs + i*NL+j
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+          write (*,*) erri,s,cs
+      endif 
+      deallocate (B2,A1)
+
+      end
+C ----------------------------------------------------align122
+c 122			                    ALIGN arrB[i][ ] WITH arrA[2*i+1]	matrix compression: 
+c                                                               line on vector element
+      subroutine align122
+      integer, parameter ::  AN1=16,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB(i,*) WITH arrA[k1i*i+li]                                                
+      integer, parameter ::  k1i=2,k2i=0,li=1
+      character*9 tname
+      integer, allocatable :: A1(:),B2(:,:)
+      integer s,cs,erri,i,j,ib,jb
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B2(i,*) WITH A1(k1i*i+li)
+
+
+      tname='align122'
+      allocate (A1(AN1),B2(BN1,BN2))
+      erri= ER
+c      call stralign122 
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri, s)
+!dvm$ region local(A1,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo
+      enddo 
+
+!dvm$ parallel (i) on A1(i), private(ib,jb,j)
+      do i=1,AN1
+          A1(i) = i
+          do j=1,BN2
+             if (  
+     *          ((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)  )then
+                jb = j
+                ib = (i-li)/k1i
+                B2(ib,jb) = ib*NL+jb
+             endif   
+          enddo 
+      enddo 
+       
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+          do j=1,BN2
+            s = s + B2(i,j)
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+                cs = cs + i*NL+j
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+          write (*,*) erri,s,cs
+      endif 
+      deallocate (B2,A1)
+      end
+C ----------------------------------------------------align123
+c 123			                    ALIGN arrB[][ ] WITH arrA[]	 
+      subroutine align123
+      integer, parameter ::  AN1=16,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB(*,*) WITH arrA[*]                                                
+      integer, parameter ::  k1i=0,k2i=0,li=0
+      character*9 tname
+      integer, allocatable :: A1(:),B2(:,:)
+      integer s,erri,i,j,ib,jb
+!dvm$ distribute A1(BLOCK)    
+!dvm$ ALIGN B2(*,*) WITH A1(*)
+
+
+      tname='align123'
+      allocate (A1(AN1),B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A1,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =i*NL+j     
+          enddo
+      enddo 
+
+!dvm$ parallel (i) on A1(i), reduction( min( erri )), private(ib,jb)
+      do i=1,AN1
+        do ib=1,BN1
+          do jb=1,BN2
+            if (B2(ib,jb) .eq.(ib*NL+jb)) then     
+            else
+               erri = min(erri,ib*NL/10+jb)
+            endif 
+          enddo 
+        enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+       
+     
+      if ((erri .eq.ER) 
+     *     ) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+          write (*,*) erri
+      endif
+      deallocate (B2,A1)
+
+      end
+C ------------------------------------------------------------
+
+
+      subroutine ansyes(name)
+      character*9 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*9 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ALIGN/align21.fdv

@@ -0,0 +1,299 @@
+      program ALIGN21
+
+c    TESTING align CLAUSE .       
+c    arrA2[BLOCK][ BLOCK] arrB1[]
+      print *,'===START OF align21========================'
+C --------------------------------------------------
+c 211       ALIGN arrB[i] WITH arrA[1][i]   vector arrB on section 
+*                                                 (the first line of arrA)
+      call align211
+C -------------------------------------------------
+c 212     ALIGN arrB[i] WITH arrA[2*i+2][2] vector arrB on section 
+*                                       (the second column of arrA) with stretching and shift
+      call align212
+C -------------------------------------------------
+c 213     ALIGN arrB[i] WITH arrA[][i]  vector replication on every line of arrA
+      call align213
+C -------------------------------------------------
+c 214     ALIGN arrB[i] WITH arrA[2*i+2][ ] vector arrB on replication on 
+*                                          every column of arrA with stretching and shift
+      call align214
+C -------------------------------------------------
+C
+C
+      print *,'=== END OF align21 ========================= '    
+      end
+
+C ----------------------------------------------------align211
+c 211 arrA2[BLOCK][ BLOCK]  arrB1[] ALIGN arrB[i] WITH arrA[1][i]vector arrB on section 
+*                                                                   (the first line of arrA)
+      subroutine align211
+      integer, parameter :: AN1=8,AN2=8,BN1=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA(1,i)                                                
+      integer, parameter :: k1i=0,k2i=0,li=1,k1j=1,k2j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B1(:)
+      integer erri,i,j,ia,ja,ib,jb
+cdvm$ distribute A2(BLOCK,BLOCK)    
+cdvm$ ALIGN B1(i) WITH A2(1,i)
+
+
+      tname='align211'
+      allocate (A2(AN1,AN2),B1(BN1))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A2,B1)
+*dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =0     
+      enddo 
+
+*dvm$ parallel (i,j) on A2(i,j), private (ib)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if ((i .eq. 1) ) then
+                      if ( 
+     *                  (j .le. BN1)  
+     *                  )  then 
+                        ib = j
+                        B1(ib) = ib
+                      endif 
+             endif   
+          enddo 
+      enddo 
+
+*dvm$ parallel (i) on B1(i),reduction( min( erri ) ), private(ia,ja)
+      do i=1,BN1
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif
+            ia=1
+            ja=i
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+                erri = min(erri,i*NL/10+j)
+            endif 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri) 
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A2)
+      end
+C ----------------------------------------------------align212
+c 212     ALIGN arrB[i] WITH arrA[2*i+2][2] vector arrB on section 
+*                                       (the second column of arrA) with stretching and shift
+      subroutine align212
+      integer, parameter :: AN1=14,AN2=3,BN1=6,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA(k1i*i+li,lj)                                                
+      integer, parameter :: k1i=2,k2i=0,li=2,k1j=0,k2j=0,lj=2
+      character*9 tname
+      integer, allocatable :: A2(:,:),B1(:)
+      integer erri
+         
+cdvm$ distribute A2(BLOCK,BLOCK)
+cdvm$ ALIGN B1(i) WITH A2(k1i*i+li,lj)
+
+      tname='align212'
+      allocate (A2(AN1,AN2),B1(BN1))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A2,B1)
+*dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =0     
+      enddo 
+
+*dvm$ parallel (i,j) on A2(i,j), private(ib)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if ((j .eq. lj) .and. 
+     *                  ((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *                  (((i-li)/k1i) .gt. 0)  .and.
+     *                  (((i-li)/k1i) .le. BN1)  
+     *                  )  then 
+               ib = (i-li)/k1i
+               B1(ib) = ib
+             endif   
+          enddo 
+      enddo 
+
+*dvm$ parallel (i) on B1(i), reduction( min( erri ) ), private(ia,ja)
+      do i=1,BN1
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif
+            ia=k1i*i+li
+            ja=lj
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+                erri = min(erri,i*NL/10+j)
+            endif 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A2)
+
+      end
+C ----------------------------------------------------align213
+c 213     ALIGN arrB[i] WITH arrA[][i]  vector replication on every line of arrA
+      subroutine align213
+      integer, parameter :: AN1=8,AN2=8,BN1=6,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA[][k1j * i + lj]                                                
+      integer, parameter :: k1i=0,k2i=0,li=0,k1j=1,k2j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B1(:)
+      integer s,cs,erri,i,j,ia,ja,ib,jb
+               
+cdvm$ distribute A2(BLOCK,BLOCK)    
+cdvm$ ALIGN B1(i) WITH A2(*,k1j * i + lj)
+
+
+      tname='align213'
+      allocate (A2(AN1,AN2),B1(BN1))
+      erri= ER
+      NNL=NL 
+      s=0
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A2,B1)
+*dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =i     
+      enddo 
+
+*dvm$ parallel (i,j) on A2(i,j), reduction( min( erri ) ), private(ib)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if (
+     *          ((j-lj) .eq.(((j-lj)/k1j) *k1j)) .and.
+     *          (((j-lj)/k1j) .gt. 0)  .and.
+     *          (((j-lj)/k1j) .le. BN1)  )then
+                ib = (j-lj)/k1j
+                if (B1(ib) .eq.(ib)) then     
+                else
+                    erri = min(erri,ib)
+                endif
+             endif   
+          enddo 
+      enddo 
+
+*dvm$ parallel (i) on B1(i), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+            s = s + B1(i)
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = ((1 + BN1)* BN1/ 2)
+c      write (*,*) erri,s,cs
+  
+      if ((erri .eq.ER) .and.
+     *     (s .eq.cs )) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+      endif 
+      deallocate (B1,A2)
+
+      end
+C ----------------------------------------------------align214
+c 214     ALIGN arrB[i] WITH arrA[2*i+2][ ] vector arrB on replication on 
+*                                          every column of arrA with stretching and shift
+      subroutine align214
+      integer, parameter :: AN1=28,AN2=8,BN1=5,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i] WITH arrA(k1i*i+li,*)                                                
+      integer, parameter :: k1i=2,k2i=0,li=2,k1j=0,k2j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B1(:)
+      integer s,erri,i,j,ia,ja,ib,jb
+               
+cdvm$ distribute A2(BLOCK,BLOCK)    
+cdvm$ ALIGN B1(i) WITH A2(k1i*i+li,*)
+
+
+      tname='align214'
+      allocate (A2(AN1,AN2),B1(BN1))
+      erri= ER
+      NNL=NL 
+      s=0  
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A2,B1)
+*dvm$ parallel (i) on B1(i)
+      do i=1,BN1
+            B1(i) =i
+      enddo 
+
+*dvm$ parallel (i,j) on A2(i,j), reduction( min( erri )), private(ib)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if (  
+     *          ((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)  )then
+                ib = (i-li)/k1i
+                if (B1(ib) .eq.(ib)) then     
+                else
+                    erri = min(erri,ib)
+                endif
+             endif   
+          enddo 
+      enddo 
+
+*dvm$ parallel (i) on B1(i), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+            s = s + B1(i)
+            if (B1(i) .eq.(i)) then     
+            else
+               erri = min(erri,i)
+            endif
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. ((1 + BN1)* BN1/ 2))) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+          write (*,*) erri,s
+      endif 
+      deallocate (B1,A2)
+
+      end
+C -------------------------------------------------
+
+      subroutine ansyes(name)
+      character*9 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*9 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ALIGN/align22.fdv

@@ -0,0 +1,598 @@
+      program ALIGN22
+
+c    TESTING align CLAUSE .       
+
+      print *,'===START OF align22========================'
+C --------------------------------------------------
+c 221	arrA2[BLOCK][ BLOCK] arrB2[][]	ALIGN arrB[i][j] WITH arrA[i][j]	normal
+      call align221
+C -------------------------------------------------
+c 222		                    	ALIGN arrB[i][j] WITH arrA[i][2*j]	stretching along j
+      call align222
+C -------------------------------------------------
+c 223			                    ALIGN arrB[i][j] WITH arrA[i+4][j]	shift along i
+      call align223
+C -------------------------------------------------
+c 224			                    ALIGN arrB[i][j] WITH arrA[-i+9][j]	reverse on i
+c      call align224
+C -------------------------------------------------
+c 225			                    ALIGN arrB[i][j] WITH arrA[i+4][j+4]shift along i and j
+      call align225
+      call align2251
+C -------------------------------------------------
+c 226			                    ALIGN arrB[i][j] WITH arrA[j][i]	rotation
+      call align226
+C -------------------------------------------------
+c 227			                    ALIGN arrB[i][j] WITH arrA[j+1][i]	rotation and shift
+      call align227
+C -------------------------------------------------
+C
+C
+      print *,'=== END OF align22 ========================= '    
+      end
+
+C ----------------------------------------------------align221
+c 221	arrA2[BLOCK][ BLOCK]	arrB2[][]	ALIGN arrB[i][j] WITH arrA[i][j]	normal
+      subroutine align221
+      integer, parameter :: AN1=8,AN2=8,BN1=8,BN2=8,NL=1000,ER=10000
+      character*9 tname
+      integer, allocatable :: A2(:,:),B2(:,:)
+      integer erri,i,j,ia,ja,ib,jb
+!dvm$ distribute A2(BLOCK,BLOCK)   
+!dvm$ ALIGN B2(i,j) WITH A2(i,j)
+
+
+      tname='align221'
+      allocate (A2(AN1,AN2),B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A2,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+  
+!dvm$ parallel (i,j) on A2(i,j)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             B2(i,j) = i*NL+j
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri )), private(ia,ja)
+      do i=1,BN1
+          do j=1,BN2
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+            ia=i
+            ja=j
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+  
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A2)
+      end
+
+
+C ----------------------------------------------------align222
+c 222		                    	ALIGN arrB[i][j] WITH arrA[i][2*j]	stretching along j
+      subroutine align222
+      integer, parameter :: AN1=8,AN2=8,BN1=8,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]                                                 
+      integer, parameter :: k1i=1,k2i=0,li=0,k1j=0,k2j=2,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B2(:,:)
+      integer erri,i,j,ia,ja,ib,jb              
+
+!dvm$ distribute A2(BLOCK,BLOCK)   
+!dvm$ ALIGN B2(i,j) WITH A2(k1i * i + li,k2j * j + lj)
+
+      tname='align222'
+      allocate (A2(AN1,AN2),B2(BN1,BN2))
+      erri= ER
+      NNL=NL
+       
+!dvm$ actual(erri)
+!dvm$ region local(A2,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          ((j-lj) .eq.(((j-lj)/k2j) *k2j)) .and.
+     *          (((i-li)/k1i) .le. BN1)  .and.
+     *          (((j-lj)/k2j) .le. BN2))  then 
+                ib = (i-li)/k1i
+                jb = (j-lj)/k2j  
+                B2(ib,jb) = ib*NL+jb
+             endif 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri )), private(ia,ja)
+      do i=1,BN1
+          do j=1,BN2
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+            ia=k1i * i + li
+            ja=k2j * j + lj
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A2)
+      end
+
+C ----------------------------------------------------align223
+c 223			                    ALIGN arrB[i][j] WITH arrA[i+4][j]	shift along i
+      subroutine align223
+      integer, parameter :: AN1=8,AN2=8,BN1=4,BN2=8,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]                                                 
+      integer, parameter :: k1i=1,k2i=0,li=4,k1j=0,k2j=1,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B2(:,:)
+      integer erri,i,j,ia,ja,ib,jb
+               
+!dvm$ distribute A2(BLOCK,BLOCK)    
+!dvm$ ALIGN B2(i,j) WITH A2(k1i * i + li,k2j * j + lj)
+
+
+      tname='align223'
+      allocate (A2(AN1,AN2),B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A2,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          ((j-lj) .eq.(((j-lj)/k2j) *k2j)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((j-lj)/k2j) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)  .and.
+     *          (((j-lj)/k2j) .le. BN2))  then 
+                ib = (i-li)/k1i
+                jb = (j-lj)/k2j  
+                B2(ib,jb) = ib*NL+jb
+             endif 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri )), private(ia,ja)
+      do i=1,BN1
+          do j=1,BN2
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+            ia=k1i * i + li
+            ja=k2j * j + lj
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A2)
+      end
+
+C ----------------------------------------------------align224
+c 224			                    ALIGN arrB[i][j] WITH arrA[-i+9][j]	reverse on i
+      subroutine align224
+      integer, parameter :: AN1=8,AN2=8,BN1=8,BN2=8,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]                                                 
+      integer, parameter :: k1i=-1,k2i=0,li=9,k1j=0,k2j=1,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B2(:,:)
+      integer erri,i,j,ia,ja,ib,jb
+               
+!dvm$ distribute A2(BLOCK,BLOCK)    
+!dvm$ ALIGN B2(i,j) WITH A2(k1i * i + li,k2j * j + lj)
+
+
+      tname='align224'
+      allocate (A2(AN1,AN2),B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A2,B2)
+
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          ((j-lj) .eq.(((j-lj)/k2j) *k2j)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((j-lj)/k2j) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)  .and.
+     *          (((j-lj)/k2j) .le. BN2))  then 
+                ib = (i-li)/k1i
+                jb = (j-lj)/k2j  
+                B2(ib,jb) = ib*NL+jb
+             endif 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri )), private(ia,ja)
+      do i=1,BN1
+          do j=1,BN2
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+            ia=k1i * i + li
+            ja=k2j * j + lj
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A2)
+      end
+
+C ----------------------------------------------------align225
+c 225			                    ALIGN arrB[i][j] WITH arrA[i+4][j+4]shift along i and j
+      subroutine align225
+      integer, parameter :: AN1=8,AN2=8,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]                                                 
+      integer, parameter :: k1i=1,k2i=0,li=4,k1j=0,k2j=1,lj=4
+      character*9 tname
+      integer, allocatable :: A2(:,:),B2(:,:)
+      integer erri,i,j,ia,ja,ib,jb
+               
+!dvm$ distribute A2(BLOCK,BLOCK)    
+!dvm$ ALIGN B2(i,j) WITH A2(k1i * i + li,k2j * j + lj)
+
+
+      tname='align225'
+      allocate (A2(AN1,AN2),B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A2,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          ((j-lj) .eq.(((j-lj)/k2j) *k2j)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((j-lj)/k2j) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)  .and.
+     *          (((j-lj)/k2j) .le. BN2))  then 
+                ib = (i-li)/k1i
+                jb = (j-lj)/k2j  
+                B2(ib,jb) = ib*NL+jb
+             endif 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri )), private(ia,ja)
+      do i=1,BN1
+          do j=1,BN2
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+            ia=k1i * i + li
+            ja=k2j * j + lj
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A2)
+      end
+C ----------------------------------------------------align2251
+c 2251			                    ALIGN arrB[i][j] WITH arrA[i+1][2*j]shift along i and j
+      subroutine align2251
+      integer, parameter :: AN1=3,AN2=4,BN1=2,BN2=2,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj]                                                 
+      integer, parameter :: k1i=1,k2i=0,li=1,k1j=0,k2j=2,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B2(:,:)
+      integer erri,i,j,ia,ja,ib,jb
+               
+!dvm$ distribute A2(BLOCK,BLOCK)    
+!dvm$ ALIGN B2(i,j) WITH A2(k1i * i + li,k2j * j + lj)
+
+
+      tname='align2251'
+      allocate (A2(AN1,AN2),B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A2,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if (((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *          ((j-lj) .eq.(((j-lj)/k2j) *k2j)) .and.
+     *          (((i-li)/k1i) .gt. 0)  .and.
+     *          (((j-lj)/k2j) .gt. 0)  .and.
+     *          (((i-li)/k1i) .le. BN1)  .and.
+     *          (((j-lj)/k2j) .le. BN2))  then 
+                ib = (i-li)/k1i
+                jb = (j-lj)/k2j  
+                B2(ib,jb) = ib*NL+jb
+             endif 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri )), private(ia,ja)
+      do i=1,BN1
+          do j=1,BN2
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+            ia=k1i * i + li
+            ja=k2j * j + lj
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A2)
+      end
+C ----------------------------------------------------align226
+c 226			                    ALIGN arrB[i][j] WITH arrA[j][i]	rotation
+      subroutine align226
+      integer, parameter :: AN1=4,AN2=4,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k2i * j + li][k1j * i + lj]                                                 
+      integer, parameter :: k1i=0,k2i=1,li=0,k1j=1,k2j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B2(:,:)
+      integer erri,i,j,ia,ja,ib,jb
+               
+!dvm$ distribute A2(BLOCK,BLOCK)   
+!dvm$ ALIGN B2(i,j) WITH A2(k2i * j + li,k1j * i + lj)
+
+
+      tname='align226'
+      allocate (A2(AN1,AN2),B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A2,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if (((i-li) .eq.(((i-li)/k2i) * k2i)) .and.
+     *          ((j-lj) .eq.(((j-lj)/k1j) *k1j)) .and.
+     *          (((i-li)/k2i) .gt. 0)  .and.
+     *          (((j-lj)/k1j) .gt. 0)  .and.
+     *          (((i-li)/k2i) .le. BN2)  .and.
+     *          (((j-lj)/k1j) .le. BN1))  then 
+                ib = (j-lj)/k1j
+                jb = (i-li)/k2i  
+                B2(ib,jb) = ib*NL+jb
+             endif 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri )), private(ia,ja)
+      do i=1,BN1
+          do j=1,BN2
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+            ia=k2i * j + li
+            ja=k1j * i + lj
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+     
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A2)
+      end
+
+
+C ----------------------------------------------------align227
+c 227			                    ALIGN arrB[i][j] WITH arrA[j+1][i]	rotation and shift
+      subroutine align227
+      integer, parameter :: AN1=8,AN2=8,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k2i * j + li][k1j * i + lj]                                                 
+      integer, parameter :: k1i=0,k2i=1,li=1,k1j=1,k2j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B2(:,:)
+      integer erri,i,j,ia,ja,ib,jb
+               
+!dvm$ distribute A2(BLOCK,BLOCK)    
+!dvm$ ALIGN B2(i,j) WITH A2(k2i * j + li,k1j * i + lj)
+
+      tname='align227'
+      allocate (A2(AN1,AN2),B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+
+!dvm$ actual(erri)
+!dvm$ region local(A2,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+             A2(i,j) = i*NL+j
+             if (((i-li) .eq.(((i-li)/k2i) * k2i)) .and.
+     *          ((j-lj) .eq.(((j-lj)/k1j) *k1j)) .and.
+     *          (((i-li)/k2i) .gt. 0)  .and.
+     *          (((j-lj)/k1j) .gt. 0)  .and.
+     *          (((i-li)/k2i) .le. BN2)  .and.
+     *          (((j-lj)/k1j) .le. BN1))  then 
+                ib = (j-lj)/k1j
+                jb = (i-li)/k2i  
+                B2(ib,jb) = ib*NL+jb
+             endif 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri )), private(ia,ja)
+      do i=1,BN1
+          do j=1,BN2
+            if (B2(i,j) .eq.(i*NL+j)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+            ia=k2i * j + li
+            ja=k1j * i + lj
+            if (A2(ia,ja) .eq.(ia*NL+ja)) then     
+            else
+               erri = min(erri,i*NL/10+j)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri)
+  
+      if (erri .eq.ER) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A2)
+      end
+
+
+C -------------------------------------------------
+
+      subroutine ansyes(name)
+      character*9 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*9 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ALIGN/align24.fdv

@@ -0,0 +1,536 @@
+      program ALIGN24
+
+c    TESTING align CLAUSE .       
+
+      print *,'===START OF align24========================'
+C --------------------------------------------------
+c      call forcat     
+C --------------------------------------------------
+c 241 arrA2[BLOCK][ BLOCK]  arrB4[ ][ ][ ][ ] ALIGN arrB[i][j][][] WITH arrA[i][j]  
+c                                                       matrix compression      
+      call align241
+C -------------------------------------------------
+c 242     ALIGN arrB[ ][ j][][i] WITH arrA[i+4][ 2*j] matrix compression
+      call align2421
+      call align2422
+C -------------------------------------------------
+c 243     ALIGN arrB[ ][ ][i][] WITH arrA[1][i] matrix compression 
+c                                                       and replication     !!
+      call align243
+C -------------------------------------------------
+      print *,'=== END OF align24 ========================'
+      end
+
+C ----------------------------------------------------align241
+c 241 arrA2[BLOCK][ BLOCK]  arrB4[ ][ ][ ][ ] ALIGN arrB[i][j][][] WITH arrA[i][j]  
+c                                                       matrix compression      
+
+      subroutine align241
+      integer, parameter :: AN1=5,AN2=5,BN1=2,BN2=2,BN3=2,BN4=2
+      integer, parameter :: PN=2,NL=10000,ER=100000
+c     parameters for ALIGN arrB[i][j][][] WITH arrA[k1i*i+li][k2j*j+lj]                                               
+      integer, parameter :: k1i=1,k2i=0,k3i=0,li=0
+      integer, parameter :: k1j=0,k2j=1,k3j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B4(:,:,:,:)
+      integer s,cs,erri,i,j,n,m,ia,ja,na,ib,jb,nb,mb,Avalue,Bvalue
+               
+!dvm$ distribute A2(BLOCK,BLOCK)   
+!dvm$ ALIGN B4(i,j,*,*) WITH A2(k1i * i + li,k2j * j + lj)
+
+
+      tname='align241'
+      allocate (A2(AN1,AN2), B4(BN1,BN2,BN3,BN4))
+      erri= ER
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A2,B4)
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m)
+      do i=1,BN1
+          do j=1,BN2
+             do n=1,BN3
+                do m=1,BN4
+                    B4(i,j,n,m) =0     
+                enddo  
+             enddo  
+          enddo  
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb,n,m,nb,mb)
+      do i=1,AN1
+          do j=1,AN2
+                A2(i,j) = i*NL/10 + j
+                do n=1,BN3
+                    do m=1,BN4
+                      if ( 
+     *                  ((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *                  ((j-lj) .eq.(((j-lj)/k2j) *k2j)) .and.
+     *                  (((i-li)/k1i) .gt. 0)  .and.
+     *                  (((j-lj)/k2j) .gt. 0)  .and.
+     *                  (((i-li)/k1i) .le. BN1)  .and.
+     *                  (((j-lj)/k2j) .le. BN2)
+     *                  )  then 
+                        ib = (i-li)/k1i
+                        jb = (j-lj)/k2j
+                        nb = n
+                        mb = m  
+                        B4(ib,jb,nb,mb)=ib*NL/10+jb*NL/100+nb*NL/1000+mb 
+                      endif 
+                    enddo
+                enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                  s = s + B4(i,j,n,m)
+                  if (B4(i,j,n,m).eq.(i*NL/10+j*NL/100+n*NL/1000+m))then     
+                  else
+                      erri = min(erri,i*NL/10 + j*NL/100+ n*NL/1000+ m)
+                  endif
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                    cs = cs + i*NL/10 + j*NL/100+ n*NL/1000+ m
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+          write (*,*) erri,s,cs
+          print *,B4  
+      endif 
+      deallocate (B4,A2)
+      end
+
+C ----------------------------------------------------align242
+c 242     ALIGN arrB[ ][ j][][i] WITH arrA[i+4][ 2*j] matrix compression
+
+      subroutine align242
+
+      integer, parameter :: AN1=3,AN2=4,BN1=2,BN2=2,BN3=2,BN4=2
+      integer, parameter :: PN=2,NL=10000,ER=100000
+c     parameters for ALIGN arrB[][j][][i] WITH arrA[k1i*i+li][k2j*j+lj]                                               
+      integer, parameter :: k1i=1,k2i=0,k3i=0,li=1
+      integer, parameter :: k1j=0,k2j=2,k3j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B4(:,:,:,:)
+      integer s,cs,erri,i,j,n,m,ia,ja,na,ib,jb,nb,mb,Avalue,Bvalue
+               
+!dvm$ distribute A2(BLOCK,BLOCK)    
+!dvm$ ALIGN B4(*,j,*,i) WITH A2(k1i * i + li,k2j * j + lj)
+
+      tname='align242'
+      allocate (A2(AN1,AN2), B4(BN1,BN2,BN3,BN4))
+      erri= ER
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A2,B4)
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m)
+      do i=1,BN1
+          do j=1,BN2
+             do n=1,BN3
+                do m=1,BN4
+                    B4(i,j,n,m) =0     
+                enddo  
+             enddo  
+          enddo  
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb,n,m,nb,mb)
+      do i=1,AN1
+          do j=1,AN2
+                A2(i,j) = i*NL/10 + j
+                do n=1,BN1
+                    do m=1,BN3
+                      if ( 
+     *                  ((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *                  ((j-lj) .eq.(((j-lj)/k2j) *k2j)) .and.
+     *                  (((i-li)/k1i) .gt. 0)  .and.
+     *                  (((j-lj)/k2j) .gt. 0)  .and.
+     *                  (((i-li)/k1i) .le. BN4)  .and.
+     *                  (((j-lj)/k2j) .le. BN2)
+     *                  )  then 
+                        mb = (i-li)/k1i
+                        jb = (j-lj)/k2j
+                        ib = n
+                        nb = m  
+                        B4(ib,jb,nb,mb)=ib*NL/10+jb*NL/100+nb*NL/1000+mb 
+                      endif 
+                    enddo
+                enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                  s = s + B4(i,j,n,m)
+                  if (B4(i,j,n,m).eq.(i*NL/10+j*NL/100+n*NL/1000+m))then     
+                  else
+                      erri = min(erri,i*NL/10 + j*NL/100+ n*NL/1000+ m)
+                  endif
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                    cs = cs + i*NL/10 + j*NL/100+ n*NL/1000+ m
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+c          write (*,*) erri,s,cs
+c          print *,B4  
+      endif 
+      deallocate (B4,A2)
+
+      end
+
+C ----------------------------------------------------align2421
+c 2421      ALIGN arrB[ ][ i][][j] WITH arrA[j+4][ 2*i] matrix compression
+
+      subroutine align2421
+      integer, parameter :: AN1=12,AN2=9,BN1=4,BN2=4,BN3=4,BN4=4
+      integer, parameter :: PN=2,NL=10000,ER=100000
+c     parameters for ALIGN arrB[][i][][j] WITH arrA[k2i*j+li][k1j*i+lj]                                               
+      integer, parameter :: k1i=0,k2i=1,k3i=0,li=4
+      integer, parameter :: k1j=2,k2j=0,k3j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B4(:,:,:,:)
+      integer s,cs,erri,i,j,n,m,ia,ja,na,ib,jb,nb,mb,Avalue,Bvalue
+               
+!dvm$ distribute A2(BLOCK,BLOCK)    
+!dvm$ ALIGN B4(*,i,*,j) WITH A2(k2i * j + li,k1j * i + lj)
+
+      tname='align2421'
+      allocate (A2(AN1,AN2), B4(BN1,BN2,BN3,BN4))
+      erri= ER
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A2,B4)
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m)
+      do i=1,BN1
+          do j=1,BN2
+             do n=1,BN3
+                do m=1,BN4
+                    B4(i,j,n,m) =0     
+                enddo  
+             enddo  
+          enddo  
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb,nb,mb,n,m)
+      do i=1,AN1
+          do j=1,AN2
+                A2(i,j) = i*NL/10 + j
+                do n=1,BN1
+                    do m=1,BN3
+                      if ( 
+     *                  ((i-li) .eq.(((i-li)/k2i) * k2i)) .and.
+     *                  ((j-lj) .eq.(((j-lj)/k1j) *k1j)) .and.
+     *                  (((i-li)/k2i) .gt. 0)  .and.
+     *                  (((j-lj)/k1j) .gt. 0)  .and.
+     *                  (((i-li)/k2i) .le. BN4)  .and.
+     *                  (((j-lj)/k1j) .le. BN2)
+     *                  )  then 
+                        mb = (i-li)/k2i
+                        jb = (j-lj)/k1j
+                        ib = n
+                        nb = m
+                        B4(ib,jb,nb,mb)=ib*NL/10+jb*NL/100+nb*NL/1000+mb 
+                      endif 
+                    enddo
+                enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                  s = s + B4(i,j,n,m)
+                  if (B4(i,j,n,m).eq.(i*NL/10+j*NL/100+n*NL/1000+m))then     
+                  else
+                      erri = min(erri,i*NL/10 + j*NL/100+ n*NL/1000+ m)
+                  endif
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                    cs = cs + i*NL/10 + j*NL/100+ n*NL/1000+ m
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+c          write (*,*) erri,s,cs
+c          print *,B4  
+      endif 
+      deallocate (B4,A2)
+
+      end
+
+C ----------------------------------------------------align2422
+c 2422      ALIGN arrB[ ][ i][][j] WITH arrA[j+1][ 2*i] matrix compression
+
+      subroutine align2422
+      integer, parameter :: AN1=3,AN2=4,BN1=2,BN2=2,BN3=2,BN4=2
+      integer, parameter :: PN=2,NL=10000,ER=100000
+c     parameters for ALIGN arrB[][i][][j] WITH arrA[k2i*j+li][k1j*i+lj]                                               
+      integer, parameter :: k1i=0,k2i=1,k3i=0,li=1
+      integer, parameter :: k1j=2,k2j=0,k3j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B4(:,:,:,:)
+      integer s,cs,erri,i,j,n,m,ia,ja,na,ib,jb,nb,mb,Avalue,Bvalue
+               
+!dvm$ distribute A2(BLOCK,BLOCK)    
+!dvm$ ALIGN B4(*,i,*,j) WITH A2(k2i * j + li,k1j * i + lj)
+
+
+      tname='align2422'
+      allocate (A2(AN1,AN2), B4(BN1,BN2,BN3,BN4))
+      erri= ER
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A2,B4)
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m)
+      do i=1,BN1
+          do j=1,BN2
+             do n=1,BN3
+                do m=1,BN4
+                    B4(i,j,n,m) =0     
+                enddo  
+             enddo  
+          enddo  
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb,nb,mb,n,m)
+      do i=1,AN1
+          do j=1,AN2
+                A2(i,j) = i*NL/10 + j
+                do n=1,BN1
+                    do m=1,BN3
+                      if ( 
+     *                  ((i-li) .eq.(((i-li)/k2i) * k2i)) .and.
+     *                  ((j-lj) .eq.(((j-lj)/k1j) *k1j)) .and.
+     *                  (((i-li)/k2i) .gt. 0)  .and.
+     *                  (((j-lj)/k1j) .gt. 0)  .and.
+     *                  (((i-li)/k2i) .le. BN4)  .and.
+     *                  (((j-lj)/k1j) .le. BN2)
+     *                  )  then 
+                        mb = (i-li)/k2i
+                        jb = (j-lj)/k1j
+                        ib = n
+                        nb = m
+                        B4(ib,jb,nb,mb)=ib*NL/10+jb*NL/100+nb*NL/1000+mb 
+                      endif 
+                    enddo
+                enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                  s = s + B4(i,j,n,m)
+                  if (B4(i,j,n,m).eq.(i*NL/10+j*NL/100+n*NL/1000+m))then     
+                  else
+                      erri = min(erri,i*NL/10 + j*NL/100+ n*NL/1000+ m)
+                  endif
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                    cs = cs + i*NL/10 + j*NL/100+ n*NL/1000+ m
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B4,A2)
+
+      end
+
+C ----------------------------------------------------align243
+c 243     ALIGN arrB[ ][ ][i][] WITH arrA[1][i] matrix compression 
+c                                                       and replication     !!
+
+      subroutine align243
+      integer, parameter :: AN1=3,AN2=4,BN1=2,BN2=2,BN3=2,BN4=2
+      integer, parameter :: PN=2,NL=10000,ER=100000
+
+c     parameters for ALIGN arrB[][ ][i][ ] WITH arrA[li][k1j*i+lj]                                               
+      integer, parameter :: k1i=0,k2i=0,k3i=0,li=1
+      integer, parameter :: k1j=1,k2j=0,k3j=0,lj=0
+      character*9 tname
+      integer, allocatable :: A2(:,:),B4(:,:,:,:)
+      integer s,cs,erri,i,j,n,m,ia,ja,na,ib,jb,nb,mb,Avalue,Bvalue
+               
+!dvm$ distribute A2(BLOCK,BLOCK)    
+!dvm$ ALIGN B4(*,*,i,*) WITH A2(li,k1j * i + lj)
+
+
+      tname='align243'
+      allocate (A2(AN1,AN2), B4(BN1,BN2,BN3,BN4))
+      erri= ER
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A2,B4)
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m)
+      do i=1,BN1
+          do j=1,BN2
+             do n=1,BN3
+                do m=1,BN4
+                    B4(i,j,n,m) =0     
+                enddo  
+             enddo  
+          enddo  
+      enddo 
+
+!dvm$ parallel (i,j) on A2(i,j), private(ib,jb,nb,mb,n,m,k)
+      do i=1,AN1
+          do j=1,AN2
+                A2(i,j) = i*NL/10 + j
+                if (i .eq. (li)) then
+                  do n=1,BN1
+                    do m=1,BN2
+                     do k=1,BN4
+                      if ( 
+     *                  ((j-lj) .eq.(((j-lj)/k1j) *k1j)) .and.
+     *                  (((j-lj)/k1j) .gt. 0)  .and.
+     *                  (((j-lj)/k1j) .le. BN3)
+     *                  )  then 
+                        mb = k
+                        jb = m
+                        ib = n
+                        nb = ((j-lj)/k1j)  
+                        B4(ib,jb,nb,mb)=ib*NL/10+jb*NL/100+nb*NL/1000+mb 
+                      endif 
+                     enddo
+                    enddo
+                  enddo
+                endif
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n,m) on B4(i,j,n,m), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                  s = s + B4(i,j,n,m)
+                  if (B4(i,j,n,m).eq.(i*NL/10+j*NL/100+n*NL/1000+m))then     
+                  else
+                      erri = min(erri,i*NL/10 + j*NL/100+ n*NL/1000+ m)
+                  endif
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                do m=1,BN4
+                    cs = cs + i*NL/10 + j*NL/100+ n*NL/1000+ m
+                enddo 
+            enddo 
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B4,A2)
+
+      end
+
+C -------------------------------------------------
+
+      subroutine ansyes(name)
+      character*9 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*9 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ALIGN/align32.fdv

@@ -0,0 +1,390 @@
+      program ALIGN32
+
+c    TESTING align CLAUSE .       
+
+      print *,'===START OF align32========================'
+C --------------------------------------------------
+c 321	arrA3[BLOCK][ BLOCK] [ BLOCK]	arrB2[][]	ALIGN arrB[i][j] WITH arrA[i][j][1]	
+c                                                   matrix on section
+      call align321
+C -------------------------------------------------
+c 322			ALIGN arrB[i][j] WITH arrA[j][i][5]	matrix on section with rotation
+      call align322
+C -------------------------------------------------
+c 323			ALIGN arrB[i][j] WITH arrA[j][1][2*i]	matrix on section with 
+c                                                       rotation and stretching
+      call align323
+C -------------------------------------------------
+c 324			ALIGN arrB[i][j] WITH arrA[][i][j]	matrix replication
+      call align324
+C -------------------------------------------------
+      print *,'=== END OF align32 ========================'
+      end
+
+C ----------------------------------------------------align321
+c 321	arrA3[BLOCK][ BLOCK] [ BLOCK]	arrB2[][]	ALIGN arrB[i][j] WITH arrA[i][j][1]	
+c                                                   matrix on section
+
+      subroutine align321
+      integer, parameter :: AN1=5,AN2=5,AN3=5,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k1i * i + li][k2j * j + lj][ln]                                                 
+      integer, parameter :: k1i=1,k2i=0,k3i=0,li=0
+      integer, parameter :: k1j=0,k2j=1,k3j=0,lj=0
+      integer, parameter :: k1n=0,k2n=0,k3n=0,ln=1
+      character*9 tname
+      integer, allocatable :: A3(:,:,:),B2(:,:)
+      integer s,cs,erri,i,j,n,ia,ja,na,ib,jb,nb,Avalue,Bvalue
+               
+!dvm$ distribute A3(BLOCK,BLOCK,BLOCK)   
+!dvm$ ALIGN B2(i,j) WITH A3(k1i * i + li,k2j * j + lj,ln)
+
+      tname='align321'
+      allocate (A3(AN1,AN2,AN3), B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A3,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n) on A3(i,j,n), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+            do n=1,AN3
+                A3(i,j,n) = i*NL/10 + j*NL/100 + n
+                if ( (n .eq. ln ) .and.
+     *              ((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *              ((j-lj) .eq.(((j-lj)/k2j) *k2j)) .and.
+     *              (((i-li)/k1i) .gt. 0)  .and.
+     *              (((j-lj)/k2j) .gt. 0)  .and.
+     *              (((i-li)/k1i) .le. BN1)  .and.
+     *              (((j-lj)/k2j) .le. BN2)
+     *              )  then 
+                    ib = (i-li)/k1i
+                    jb = (j-lj)/k2j  
+                    B2(ib,jb) = ib*NL/10 + jb*NL/100 
+                endif 
+            enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri ),sum(s) ),
+!dvm$* private(ia,ja,na)
+      do i=1,BN1
+          do j=1,BN2
+            s = s + B2(i,j)
+            if (B2(i,j) .eq.(i*NL/10 + j*NL/100)) then     
+            else
+               erri = min(erri,i*NL/10 + j*NL/100)
+            endif
+            ia=k1i * i + li
+            ja=k2j * j + lj
+            na = ln 
+            if (A3(ia,ja,na) .eq.(ia*NL/10 + ja*NL/100 + na)) then     
+            else
+               erri = min(erri,ia*NL/10 + ja*NL/100 + na)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+                cs = cs + i*NL/10 + j*NL/100
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+c          write (*,*) erri,s,cs
+      endif 
+      deallocate (B2,A3)
+
+      end
+
+C ----------------------------------------------------align322
+c 322			ALIGN arrB[i][j] WITH arrA[j][i][5]	matrix on section with rotation
+
+      subroutine align322
+      integer, parameter :: AN1=5,AN2=5,AN3=5,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k2i * j + li][k1j * i + lj][ln]                                                 
+      integer, parameter :: k1i=0,k2i=1,k3i=0,li=0
+      integer, parameter :: k1j=1,k2j=0,k3j=0,lj=0
+      integer, parameter :: k1n=0,k2n=0,k3n=0,ln=5
+      character*9 tname
+      integer, allocatable :: A3(:,:,:),B2(:,:)
+      integer s,cs,erri,i,j,n,ia,ja,na,ib,jb,nb,Avalue,Bvalue
+               
+!dvm$ distribute A3(BLOCK,BLOCK,BLOCK)   
+!dvm$ ALIGN B2(i,j) WITH A3(k2i * j + li,k1j * i + lj,ln)
+
+
+      tname='align322'
+      allocate (A3(AN1,AN2,AN3), B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A3,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n) on A3(i,j,n), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+            do n=1,AN3
+                A3(i,j,n) = i*NL/10 + j*NL/100 + n
+                if ( (n .eq. ln ) .and.
+     *              ((i-li) .eq.(((i-li)/k2i) * k2i)) .and.
+     *              ((j-lj) .eq.(((j-lj)/k1j) *k1j)) .and.
+     *              (((i-li)/k2i) .gt. 0)  .and.
+     *              (((j-lj)/k1j) .gt. 0)  .and.
+     *              (((i-li)/k2i) .le. BN2)  .and.
+     *              (((j-lj)/k1j) .le. BN1)
+     *              )  then 
+                    ib = (j-lj)/k1j
+                    jb = (i-li)/k2i  
+                    B2(ib,jb) = ib*NL/10 + jb*NL/100 
+                endif 
+            enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri ),sum(s) ),
+!dvm$* private(ia,ja,na)
+      do i=1,BN1
+          do j=1,BN2
+            s = s + B2(i,j)
+            if (B2(i,j) .eq.(i*NL/10 + j*NL/100)) then     
+            else
+               erri = min(erri,i*NL/10 + j*NL/100)
+            endif
+            ia=k2i * j + li
+            ja=k1j * i + lj
+            na = ln 
+            if (A3(ia,ja,na) .eq.(ia*NL/10 + ja*NL/100 + na)) then     
+            else
+               erri = min(erri,ia*NL/10 + ja*NL/100 + na)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+                cs = cs + i*NL/10 + j*NL/100
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A3)
+
+      end
+
+C ----------------------------------------------------align323
+c 323			ALIGN arrB[i][j] WITH arrA[j][1][2*i]	matrix on section with 
+c                                                       rotation and stretching
+      subroutine align323
+      integer, parameter :: AN1=5,AN2=2,AN3=8,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[k2i * j + li][lj][k1n * i + ln]                                                 
+      integer, parameter :: k1i=0,k2i=1,k3i=0,li=0
+      integer, parameter :: k1j=0,k2j=0,k3j=0,lj=1
+      integer, parameter :: k1n=2,k2n=0,k3n=0,ln=0
+      character*9 tname
+      integer, allocatable :: A3(:,:,:),B2(:,:)
+      integer s,cs,erri,i,j,n,ia,ja,na,ib,jb,nb,Avalue,Bvalue
+               
+!dvm$ distribute A3(BLOCK,BLOCK,BLOCK)   
+!dvm$ ALIGN B2(i,j) WITH A3(k2i * j + li,lj,k1n * i + ln)
+
+      tname='align323'
+      allocate (A3(AN1,AN2,AN3), B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A3,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =0     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n) on A3(i,j,n), private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+            do n=1,AN3
+                A3(i,j,n) = i*NL/10 + j*NL/100 + n
+                if ( (j .eq. lj ) .and.
+     *              ((i-li) .eq.(((i-li)/k2i) * k2i)) .and.
+     *              ((n-ln) .eq.(((n-ln)/k1n) *k1n)) .and.
+     *              (((i-li)/k2i) .gt. 0)  .and.
+     *              (((n-ln)/k1n) .gt. 0)  .and.
+     *              (((i-li)/k2i) .le. BN2)  .and.
+     *              (((n-ln)/k1n) .le. BN1)
+     *              )  then 
+                    ib = (n-ln)/k1n
+                    jb = (i-li)/k2i  
+                    B2(ib,jb) = ib*NL/10 + jb*NL/100 
+                endif 
+            enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri ),sum(s) ),
+!dvm$* private(ia,ja,na)
+      do i=1,BN1
+          do j=1,BN2
+            s = s + B2(i,j)
+            if (B2(i,j) .eq.(i*NL/10 + j*NL/100)) then     
+            else
+               erri = min(erri,i*NL/10 + j*NL/100)
+            endif
+            ia=k2i * j + li
+            ja=lj
+            na = k1n * i + ln 
+            if (A3(ia,ja,na) .eq.(ia*NL/10 + ja*NL/100 + na)) then     
+            else
+               erri = min(erri,ia*NL/10 + ja*NL/100 + na)
+            endif 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+                cs = cs + i*NL/10 + j*NL/100
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+          else
+          call ansno(tname)
+c          write (*,*) erri,s,cs
+      endif 
+      deallocate (B2,A3)
+
+      end
+C ----------------------------------------------------align324
+c 324			ALIGN arrB[i][j] WITH arrA[][i][j]	matrix replication
+      subroutine align324
+      integer, parameter :: AN1=4,AN2=6,AN3=6,BN1=4,BN2=4,NL=1000,ER=10000
+c     parameters for ALIGN arrB[i][j] WITH arrA[*,k1j * i + lj,k2n * j + ln]                                                 
+      integer, parameter :: k1i=0,k2i=0,k3i=0,li=0
+      integer, parameter :: k1j=1,k2j=0,k3j=0,lj=0
+      integer, parameter :: k1n=0,k2n=1,k3n=0,ln=0
+      character*9 tname
+      integer, allocatable :: A3(:,:,:),B2(:,:)
+      integer s,cs,erri,i,j,n,ia,ja,na,ib,jb,nb,Avalue,Bvalue
+               
+!dvm$ distribute A3(BLOCK,BLOCK,BLOCK)    
+!dvm$ ALIGN B2(i,j) WITH A3(*,k1j * i + lj,k2n * j + ln)
+
+
+      tname='align324'
+      allocate (A3(AN1,AN2,AN3), B2(BN1,BN2))
+      erri= ER
+      NNL=NL 
+      s=0 
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A3,B2)
+!dvm$ parallel (i,j) on B2(i,j)
+      do i=1,BN1
+          do j=1,BN2
+            B2(i,j) =i*NL/10 + j*NL/100     
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n) on A3(i,j,n), reduction( min( erri ) ),
+!dvm$* private(ib,jb)
+      do i=1,AN1
+          do j=1,AN2
+            do n=1,AN3
+                A3(i,j,n) = i*NL/10 + j*NL/100 + n
+                if ( 
+     *              ((j-lj) .eq.(((j-lj)/k1j) * k1j)) .and.
+     *              ((n-ln) .eq.(((n-ln)/k2n) *k2n)) .and.
+     *              (((j-lj)/k1j) .gt. 0)  .and.
+     *              (((n-ln)/k2n) .gt. 0)  .and.
+     *              (((j-lj)/k1j) .le. BN1)  .and.
+     *              (((n-ln)/k2n) .le. BN2)
+     *              )  then 
+                    jb = (n-ln)/k2n
+                    ib = (j-lj)/k1j  
+                    if (B2(ib,jb) .eq.(ib*NL/10 + jb*NL/100)) then     
+                    else
+                        erri = ib*NL/10 + jb*NL/100
+                    endif
+                endif 
+            enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j) on B2(i,j), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+          do j=1,BN2
+            s = s + B2(i,j)
+            if (B2(i,j) .eq.(i*NL/10 + j*NL/100)) then     
+            else
+               erri = min(erri,i*NL/10 + j*NL/100)
+            endif
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+                cs = cs + i*NL/10 + j*NL/100
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+      endif 
+      deallocate (B2,A3)
+
+      end
+C -------------------------------------------------
+      subroutine ansyes(name)
+      character*9 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*9 name
+      print *,name,'  -  ***error'
+      end

dvm/tools/tester/trunk/test-suite/Correctness/Fortran/ALIGN/align33.fdv

@@ -0,0 +1,120 @@
+      program ALIGN33
+
+c    TESTING align CLAUSE .       
+
+      print *,'===START OF align33========================'
+C --------------------------------------------------
+c 331 arrA3[BLOCK][BLOCK] [BLOCK]  arrB3[][][]
+c       ALIGN arrB[i][j][k] WITH arrA[i][ j][k] normal      
+        call align331
+C -------------------------------------------------
+C
+      print *,'=== END OF align33 ========================= '    
+      end
+
+C ----------------------------------------------------align331
+c 331 arrA3[BLOCK][BLOCK] [BLOCK]  arrB3[][][] 
+c       ALIGN arrB[i][j][n] WITH arrA[i][ j][n] normal      
+
+      subroutine align331
+      integer, parameter :: AN1=5,AN2=5,AN3=5,BN1=2,BN2=2,BN3=2
+      integer, parameter :: NL=10000,ER=100000
+c     parameters for ALIGN arrB[i][j][n] WITH arrA[k1i*i+li][k2j*j+lj][k3n*n+ln]                                               
+      integer, parameter :: k1i=1,k2i=0,k3i=0,li=0
+      integer, parameter :: k1j=0,k2j=1,k3j=0,lj=0
+      integer, parameter :: k1n=0,k2n=0,k3n=1,ln=0
+      character*9 tname
+      integer, allocatable :: A3(:,:,:),B3(:,:,:)
+      integer s,cs,erri,i,j,n,m,ia,ja,na,ma,ib,jb,nb,mb,Avalue,Bvalue
+               
+!dvm$ distribute A3(BLOCK,BLOCK,BLOCK)    
+!dvm$ ALIGN B3(i,j,n) WITH A3(k1i*i+li,k2j*j+lj,k3n*n+ln)
+
+      tname='align331'
+      allocate (A3(AN1,AN2,AN3),B3(BN1,BN2,BN3))
+      erri= ER
+      NNL=NL 
+      s=0
+      m=-1
+
+!dvm$ actual(erri,s)
+!dvm$ region local(A3,B3)
+!dvm$ parallel (i,j,n) on B3(i,j,n)
+      do i=1,BN1
+          do  j=1,BN2
+             do n=1,BN3
+                    B3(i,j,n) =0     
+             enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n) on A3(i,j,n), private(ib,jb,nb)
+      do i=1,AN1
+          do j=1,AN2
+            do n=1,AN3
+                A3(i,j,n) = i*NL/10+j*NL/100+n*NL/1000+m
+                      if ( 
+     *                  ((i-li) .eq.(((i-li)/k1i) * k1i)) .and.
+     *                  ((j-lj) .eq.(((j-lj)/k2j) *k2j)) .and.
+     *                  ((n-ln) .eq.(((n-ln)/k3n) * k3n)) .and.
+     *                  (((i-li)/k1i) .gt. 0)  .and.
+     *                  (((j-lj)/k2j) .gt. 0)  .and.
+     *                  (((n-ln)/k3n) .gt. 0)  .and.
+     *                  (((i-li)/k1i) .le. BN1)  .and.
+     *                  (((j-lj)/k2j) .le. BN2)  .and.
+     *                  (((n-ln)/k3n) .le. BN3)  
+     *                  )  then 
+                        ib = (i-li)/k1i
+                        jb = (j-lj)/k2j
+                        nb = (n-ln)/k3n
+                        B3(ib,jb,nb)=ib*NL/10+jb*NL/100+nb*NL/1000 
+                      endif 
+            enddo 
+          enddo 
+      enddo 
+
+!dvm$ parallel (i,j,n) on B3(i,j,n), reduction( min( erri ),sum(s) )
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                  s = s + B3(i,j,n)
+                  if (B3(i,j,n).eq.(i*NL/10+j*NL/100+n*NL/1000))then     
+                  else
+                      erri = min(erri, i*NL/10 + j*NL/100+ n*NL/1000)
+                  endif
+            enddo 
+          enddo 
+      enddo 
+!dvm$ end region
+!dvm$ get_actual(erri,s)
+  
+      cs = 0              
+      do i=1,BN1
+          do j=1,BN2
+            do n=1,BN3
+                    cs = cs + i*NL/10 + j*NL/100+ n*NL/1000
+            enddo 
+          enddo 
+      enddo 
+     
+      if ((erri .eq.ER) .and.
+     *     (s .eq. cs)) then     
+          call ansyes(tname)
+      else
+          call ansno(tname)
+c           write (*,*) erri,s,cs
+c          print *,B3  
+      endif 
+      deallocate (B3,A3)
+
+      end
+
+C -------------------------------------------------
+      subroutine ansyes(name)
+      character*9 name
+      print *,name,'  -  complete'
+      end
+      subroutine ansno(name)
+      character*9 name
+      print *,name,'  -  ***error'
+      end