added tests

.gitignore

@@ -49,7 +49,6 @@ dvm/rts-dvmh/
 dvm/tools/projectStructureForFortran/
 dvm/tools/pppa/.svn
 dvm/tools/Zlib/.svn
-dvm/tools/tester/
 dvm/tools/predictor/
 dvm/tools/omp-dbg/
 dvm/tools/omp-otc/

dvm/tools/tester/trunk/automation/build-and-test.sh

@@ -0,0 +1,104 @@
+#!/bin/sh
+
+SAVE_DIR=`pwd`
+MY_DIR=$(cd "$(dirname "$(which "$0")")" && pwd)
+
+if [ "$1" = "--continue" ]; then
+    CONTINUE_FLAG=1
+    shift
+else
+    CONTINUE_FLAG=0
+fi
+ORIG_DIR="$1"
+REV_NUMBER=$2
+
+if [ -f "$SAVE_DIR/dvm-tester.config" ]; then
+    . "$SAVE_DIR/dvm-tester.config"
+fi
+
+if [ -z "$PLATFORMS" ]; then
+    exit 1
+fi
+
+if [ -z "$TEST_SUITE" ]; then
+    exit 1
+fi
+
+FULL_REP_URL="$PUBL_BASE_URL/r${REV_NUMBER}${PUBL_SUFFIX}/"
+
+TEST_SUITE=$(cd "$TEST_SUITE" && pwd)
+
+# Actually, can be taken any temporary name
+RESULTS_DIR="$ORIG_DIR.results"
+export TMPDIR="$ORIG_DIR.work"
+if [ -d "/home/scratch" ]; then
+    TEMPL_NAME="/home/scratch/$(basename "$TMPDIR").XXX"
+    TMPDIR=$(mktemp -d "$TEMPL_NAME")
+fi
+mkdir -p "$TMPDIR"
+
+# Launch task processor
+TASK_FIFO="$(mktemp -u).task-fifo"
+mkfifo "$TASK_FIFO"
+if [ $CONTINUE_FLAG -eq 0 ]; then
+    rm -rf "$RESULTS_DIR"
+fi
+mkdir -p "$RESULTS_DIR"
+cd "$SAVE_DIR"
+"$MY_DIR/task-processor.sh" "$RESULTS_DIR" <"$TASK_FIFO" &
+
+# Build DVM-systems for given platforms and sequentially feed task processor from our test-suite
+exec 4>"$TASK_FIFO"
+for platf in $PLATFORMS; do
+    WORK_DIR="$ORIG_DIR.$platf"
+    if [ $CONTINUE_FLAG -eq 0 ]; then
+        rm -rf "$WORK_DIR"
+    fi
+    if [ ! -e "$WORK_DIR" ]; then
+        cp -r "$ORIG_DIR" "$WORK_DIR"
+    fi
+    cd "$WORK_DIR/dvm_sys"
+    if [ ! -f platforms/$platf ]; then
+        if [ -f "$SAVE_DIR/$platf" ]; then
+            cp "$SAVE_DIR/$platf" platforms/
+        else
+            echo "Can not find platform $platf"
+        fi
+    fi
+    if [ -f platforms/$platf ]; then
+        PLATFORM=$platf ./dvminstall >install.log 2>& 1
+        INST_RES=$?
+        if [ $INST_RES -ne 0 -o ! -f user/dvm ]; then
+            :
+            # TODO: Handle errors with building DVM-system
+        else
+            cd "$SAVE_DIR"
+            "$MY_DIR/perform-tests.sh" "$WORK_DIR/dvm_sys" "$TEST_SUITE" 4
+        fi
+    fi
+done
+exec 4>&-
+
+# Wait for task processor to finish
+wait
+
+# Cleanup stuff
+rm "$TASK_FIFO"
+for platf in $PLATFORMS; do
+    WORK_DIR="$ORIG_DIR.$platf"
+#    rm -rf "$WORK_DIR"
+done
+
+# Generate final report
+cd "$SAVE_DIR"
+"$MY_DIR/gen-report.sh" "$TEST_SUITE" "$RESULTS_DIR" "$FULL_REP_URL" $REV_NUMBER
+
+# Publish the report and send summary e-mail
+if [ "$POPULATE_FLAG" = "1" ]; then
+    cd "$SAVE_DIR"
+    "$MY_DIR/populate-report.sh" "$RESULTS_DIR" "$REV_NUMBER"
+fi
+
+# Cleanup stuff finally
+#rm -rf "$RESULTS_DIR"
+#rm -rf "$TMPDIR"

dvm/tools/tester/trunk/automation/check-repo.sh

@@ -0,0 +1,65 @@
+#!/bin/sh
+
+unset CDPATH
+
+REPO_URL=http://svn.dvm-system.org/svn/dvmhrepo/dvm
+REPO_USER=dvmhuser
+REPO_PASS=dvmh2013
+PATHS_OF_INTEREST="cdvm/trunk cdvmh-clang/trunk driver/trunk fdvm/trunk general/examples/trunk general/platforms/trunk general/trunk rts/trunk rts-dvmh/trunk tools/pppa/trunk tools/predictor/trunk"
+
+SVN_PARAMS="--username $REPO_USER --password $REPO_PASS --non-interactive"
+
+PREV_REV=`cat latest-seen-revision`
+[ "$PREV_REV" -ge 0 ] 2>/dev/null
+if [ $? -ne 0 ]; then
+    PREV_REV=0
+fi
+
+NEW_REV=`svn info $SVN_PARAMS $REPO_URL | grep "Revision" | awk '{ print $2 }'`
+[ "$NEW_REV" -ge 1 ] 2>/dev/null
+if [ $? -ne 0 ]; then
+    NEW_REV=0
+fi
+
+# If latest-seen-revision is corrupted, then inspect only latest revision
+if [ $PREV_REV -eq 0 -a $NEW_REV -gt 0 ]; then
+    PREV_REV=$(( NEW_REV - 1 ))
+fi
+
+CUR_REV=$(( PREV_REV + 1 ))
+while [ $CUR_REV -le $NEW_REV ]; do
+    TO_TEST=1
+    COMMIT_MSG=`svn log $SVN_PARAMS --incremental -c $CUR_REV $REPO_URL | tail -n +4`
+    IS_INTERMEDIATE=`echo "$COMMIT_MSG" | grep -i "intermediate" | wc -l`
+    IS_TRIVIAL=`echo "$COMMIT_MSG" | grep -i "trivial" | wc -l`
+    IS_COSMETICS=`echo "$COMMIT_MSG" | grep -i "cosmetics" | wc -l`
+    IS_MAJOR=`echo "$COMMIT_MSG" | grep -i "major" | wc -l`
+    if [ $IS_INTERMEDIATE -ne 0 -o $IS_TRIVIAL -ne 0 -o $IS_COSMETICS -ne 0 ]; then
+        TO_TEST=0
+    elif [ $IS_MAJOR -ne 0 ]; then
+        TO_TEST=2
+    fi
+    if [ $TO_TEST -ne 0 -a -n "$PATHS_OF_INTEREST" ]; then
+        NO_TEST=1
+        for p in $PATHS_OF_INTEREST; do
+            WHAT_CHANGED=`svn diff $SVN_PARAMS --summarize -c $CUR_REV $REPO_URL/$p`
+            if [ -n "$WHAT_CHANGED" ]; then
+                NO_TEST=0
+                break
+            fi
+        done
+        if [ $NO_TEST -ne 0 ]; then
+            TO_TEST=0
+        fi
+    fi
+    if [ $TO_TEST -eq 1 ]; then
+        echo $CUR_REV >>pending-revisions
+    elif [ $TO_TEST -eq 2 ]; then
+        echo $CUR_REV >>pending-revisions-full
+    fi
+    CUR_REV=$(( CUR_REV + 1 ))
+done
+
+if [ $NEW_REV -gt 0 ]; then
+    echo $NEW_REV >latest-seen-revision
+fi

dvm/tools/tester/trunk/automation/dvm-tester.config

@@ -0,0 +1,19 @@
+PLATFORMS="Titan"
+
+TEST_SUITE="test-suite"
+RECIPIENTS="krukov@keldysh.ru, bakhtin@keldysh.ru, pritmick@yandex.ru, alex-w900i@yandex.ru, valex@keldysh.ru, savol@keldysh.ru, socol@keldysh.ru, konov@keldysh.ru"
+
+REPO_BASE_URL="http://svn.dvm-system.org/svn/dvmhrepo"
+REPO_USER="dvmhuser"
+REPO_PASS="dvmh2013"
+
+LIST_SERVER="admdvm@svn.dvm-system.org"
+LIST_PATH="/home/admdvm/pending-revisions"
+
+PUBL_BASE_URL="http://svn.dvm-system.org/dvm-test-results"
+PUBL_SERVER="admdvm@svn.dvm-system.org"
+PUBL_BASE_PATH="/var/www/html/dvm-test-results"
+PUBL_SUFFIX=
+
+MAIL_SERVER="admdvm@svn.dvm-system.org"
+SENDMAIL="/usr/sbin/sendmail"

dvm/tools/tester/trunk/automation/dvm-tester.sh

@@ -0,0 +1,73 @@
+#!/bin/sh
+
+unset CDPATH
+
+MY_DIR=$(cd "$(dirname "$(which "$0")")" && pwd)
+
+MAX_INVOCATIONS=-1
+WAIT_INTERVAL=60
+WORKING_DIR=`pwd`
+
+parse_params() {
+    while [ -n "$1" ]; do
+        if [ "$1" = "--once" ]; then
+            MAX_INVOCATIONS=1
+        elif [ "$1" = "--max-invocations" ]; then
+            MAX_INVOCATIONS=$2
+            shift
+        elif [ "$1" = "--working-dir" ]; then
+            WORKING_DIR="$2"
+            shift
+        elif [ "$1" = "--wait-interval" ]; then
+            WAIT_INTERVAL=$2
+            shift
+        fi
+        shift
+    done
+}
+
+parse_params "$@"
+
+if [ -f "$WORKING_DIR/dvm-tester.config" ]; then
+    . "$WORKING_DIR/dvm-tester.config"
+else
+    echo "No dvm-tester.config found!" >& 2
+    exit 1
+fi
+
+if [ $MAX_INVOCATIONS -lt 0 ]; then
+    INF_MODE=1
+else
+    INF_MODE=0
+fi
+
+counter=0
+while [ $INF_MODE -ne 0 -o $counter -lt $MAX_INVOCATIONS ]; do
+    while true; do
+        if [ -f "$WORKING_DIR/dvm-tester.pause" ] && [ -n "$(cat "$WORKING_DIR/dvm-tester.pause")" ]; then
+            echo "[$(date)] Paused explicitly (local)"
+        elif [ -f "$MY_DIR/dvm-tester.pause" ] && [ -n "$(cat "$MY_DIR/dvm-tester.pause")" ]; then
+            echo "[$(date)] Paused explicitly (global)"
+        elif [ $(ps aux | grep task-processor.sh | wc -l) -gt 1 ]; then
+            echo "[$(date)] Waiting existing task-processor.sh process to finish"
+        else
+            break
+        fi
+        sleep $WAIT_INTERVAL
+    done
+    echo "[$(date)] Attempting to get pending revision number"
+    REV=`ssh $LIST_SERVER "head -n 1 $LIST_PATH && tail -n +2 $LIST_PATH >$LIST_PATH.tmp && mv $LIST_PATH.tmp $LIST_PATH"`
+    echo "[$(date)] Got '$REV'"
+    if [ -z "$REV" ]; then
+        if [ $INF_MODE -ne 0 ]; then
+            sleep $WAIT_INTERVAL
+            continue
+        else
+            break
+        fi
+    fi
+    "$MY_DIR/test-revision.sh" --working-dir "$WORKING_DIR" --populate $REV
+    counter=$(( counter + 1 ))
+done
+
+echo "[$(date)] Exiting normally"

dvm/tools/tester/trunk/automation/populate-report.sh

@@ -0,0 +1,38 @@
+#!/bin/sh
+
+SAVE_DIR=`pwd`
+MY_DIR=$(cd "$(dirname "$(which "$0")")" && pwd)
+
+RESULTS_DIR="$1"
+REV_NUMBER=$2
+
+if [ -f "$SAVE_DIR/dvm-tester.config" ]; then
+    . "$SAVE_DIR/dvm-tester.config"
+fi
+
+if [ -z "$RECIPIENTS" ]; then
+    RECIPIENTS="pritmick@yandex.ru"
+fi
+
+PUBL_PATH="$PUBL_BASE_PATH/r${REV_NUMBER}${PUBL_SUFFIX}"
+COPY_PATHS="$PUBL_BASE_PATH/latest${PUBL_SUFFIX}"
+
+ssh $PUBL_SERVER "mkdir -p \"$PUBL_PATH\""
+scp "$RESULTS_DIR/report/full-report.html" "$PUBL_SERVER:$PUBL_PATH/index.html"
+scp "$RESULTS_DIR/report/sources.tgz" "$PUBL_SERVER:$PUBL_PATH/sources.tgz"
+for p in $COPY_PATHS; do
+    ssh $PUBL_SERVER "rm -rf \"$p\"; cp -r \"$PUBL_PATH\" \"$p\""
+done
+create_email()
+{
+    echo "MIME-Version: 1.0"
+    echo "Content-type: text/html;charset=UTF-8"
+    echo "From: dvm@keldysh.ru"
+    echo "To: $RECIPIENTS"
+    echo "Subject: DVM tester: Test results for revision $REV_NUMBER"
+    echo
+    cat "$1"
+    echo "."
+    echo
+}
+create_email "$RESULTS_DIR/report/brief-report.html" | ssh $MAIL_SERVER "$SENDMAIL $RECIPIENTS"

dvm/tools/tester/trunk/automation/test-revision.sh

@@ -0,0 +1,100 @@
+#!/bin/sh
+
+unset CDPATH
+
+MY_DIR=$(cd "$(dirname "$(which "$0")")" && pwd)
+
+POPULATE_FLAG=0
+WORKING_DIR=`pwd`
+REV=
+
+parse_params() {
+    while [ -n "$1" ]; do
+        if [ "$1" = "--working-dir" ]; then
+            WORKING_DIR="$2"
+            shift
+        elif [ "$1" = "--populate" ]; then
+            POPULATE_FLAG=1
+        else
+            REV=$1
+        fi
+        shift
+    done
+}
+
+parse_params $@
+
+if [ -z "$REV" ]; then
+    exit 1
+fi
+
+if [ -f "$WORKING_DIR/dvm-tester.config" ]; then
+    . "$WORKING_DIR/dvm-tester.config"
+else
+    exit 1
+fi
+
+REPO_URL="$REPO_BASE_URL/dvm/releases/current-trunk"
+SVN_PARAMS="--username $REPO_USER --password $REPO_PASS --non-interactive"
+
+update_test_suite() {
+    if [ -e "$TEST_SUITE/.svn" ]; then
+        ( cd "$TEST_SUITE" && svn $SVN_PARAMS update )
+    fi
+}
+
+test_revision() {
+    REV=$1
+    echo "[$(date)] Testing revision $REV"
+    SAVE_DIR=`pwd`
+    WORK_DIR="$WORKING_DIR/dvm_r$REV"
+    rm -rf "$WORK_DIR"
+    svn co $SVN_PARAMS -r $REV "$REPO_URL" "$WORK_DIR" >/dev/null
+    SVN_RES=$?
+    while [ $SVN_RES -ne 0 ]; do
+        sleep 1
+        rm -rf "$WORK_DIR"
+        svn co $SVN_PARAMS -r $REV "$REPO_URL" "$WORK_DIR" >/dev/null
+        SVN_RES=$?
+    done
+    cd "$WORK_DIR"
+    TMP_FILE=`mktemp`
+    svn propget svn:externals >$TMP_FILE
+    SVN_RES=$?
+    while [ $SVN_RES -ne 0 ]; do
+        svn propget svn:externals >$TMP_FILE
+        SVN_RES=$?
+    done
+    CHILDREN=`cat $TMP_FILE | sed '/^$/d' | awk '{print $(NF)}'`
+    rm $TMP_FILE
+    for d in $CHILDREN; do
+        cd "$WORK_DIR/$d"
+        svn up $SVN_PARAMS -r $REV >/dev/null
+        SVN_RES=$?
+        while [ $SVN_RES -ne 0 ]; do
+            sleep 1
+            svn cleanup $SVN_PARAMS
+            svn up $SVN_PARAMS -r $REV >/dev/null
+            SVN_RES=$?
+        done
+    done
+    rm -rf "$WORK_DIR.tmp"
+    mv "$WORK_DIR" "$WORK_DIR.tmp"
+    svn export "$WORK_DIR.tmp" "$WORK_DIR" >/dev/null
+    SVN_RES=$?
+    while [ $SVN_RES -ne 0 ]; do
+        sleep 1
+        rm -rf "$WORK_DIR"
+        svn export "$WORK_DIR.tmp" "$WORK_DIR" >/dev/null
+        SVN_RES=$?
+    done
+    rm -rf "$WORK_DIR.tmp"
+    cd "$WORKING_DIR"
+    POPULATE_FLAG=$POPULATE_FLAG "$MY_DIR/build-and-test.sh" "$WORK_DIR" $REV
+    echo "[$(date)] Testing revision $REV done"
+#    rm -rf "$WORK_DIR"
+    cd "$SAVE_DIR"
+}
+
+update_test_suite
+test_revision $REV

dvm/tools/tester/trunk/main/configure-run.sh

@@ -0,0 +1,86 @@
+#!/bin/sh
+
+# Common part
+MAX_PPN=60
+MAX_CPU_SHARING_FACTOR=4
+MAX_CUDA_SHARING_FACTOR=16
+
+# Default
+NODE_COUNT=1
+MAX_NODES_PER_TASK=1
+INTERACTIVE=1
+HAS_RES_MANAGER=0
+
+# Specializations
+if [ `hostname` = "k100" ]; then
+    NODE_COUNT=64
+    MAX_NODES_PER_TASK=8
+    INTERACTIVE=0
+    # Since launch isn't interactive - one must provide is_launched, is_finished, get_elapsed_time, stdout_fn, stderr_fn calls
+    get_task_dir() {
+        local n
+        for n in 1 2 3 4 5 6 7 8 9; do
+            if [ -d "$1.$n" ]; then
+                printf %s "$1.$n"
+                return
+            fi
+        done
+        printf %s "$1"
+    }
+    is_launched() {
+        local STDOUT_FN
+        STDOUT_FN="$1"
+        local STDERR_FN
+        STDERR_FN="$2"
+        # Add handling for refuses from SUPPZ
+        echo 1
+    }
+    is_finished() {
+        if [ "$(tail -n 1 $(get_task_dir "$1")/manager.log)" = "Exiting..." ]; then
+            echo 1
+        else
+            echo 0
+        fi
+    }
+    get_elapsed_time() {
+        local da
+        local mo
+        local ye
+        local dat
+        local tim
+        local sec1
+        local sec2
+        local task_dir
+        task_dir="$(get_task_dir "$1")"
+        dat=`grep "started at" <"$task_dir/manager.log" | awk '{print $5}' | sed 's/\./ /g'`
+        tim=`grep "started at" <"$task_dir/manager.log" | awk '{print $6}'`
+        da=`echo "$dat" | awk '{print $1}'`
+        mo=`echo "$dat" | awk '{print $2}'`
+        ye=`echo "$dat" | awk '{print $3}'`
+        dat="$ye-$mo-$da $tim"
+        sec1=`date -d "$dat" +%s`
+        dat=`grep "done at" <"$task_dir/manager.log" | awk '{print $6}' | sed 's/\./ /g'`
+        tim=`grep "done at" <"$task_dir/manager.log" | awk '{print $7}'`
+        da=`echo "$dat" | awk '{print $1}'`
+        mo=`echo "$dat" | awk '{print $2}'`
+        ye=`echo "$dat" | awk '{print $3}'`
+        dat="$ye-$mo-$da $tim"
+        sec2=`date -d "$dat" +%s`
+        echo $(( sec2 - sec1 ))
+    }
+    stdout_fn() {
+        echo "$(get_task_dir "$1")/output"
+    }
+    stderr_fn() {
+        echo "$(get_task_dir "$1")/errors"
+    }
+    HAS_RES_MANAGER=1
+    # Since machine has resource manager (task queue) - one must provide can_launch call
+    can_launch() {
+        if [ `mps 2>/dev/null | tail -n +3 | wc -l` -lt 6 ]; then
+            echo 1
+        else
+            echo 0
+        fi
+    }
+fi

dvm/tools/tester/trunk/main/default-test-analyzer.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+
+# Requires variables: LAUNCH_EXIT_CODE, STDERR_FN
+# Produces variables: TEST_PASSED, RESULT_COMMENT, ERROR_LEVEL
+
+if [ `grep -E 'Assertion' <"$STDERR_FN" | wc -l` -gt 0 ]; then
+    TEST_PASSED=0
+    RESULT_COMMENT="Assertion failed"
+    ERROR_LEVEL=3
+elif [ `grep -E 'RTS fatal' <"$STDERR_FN" | wc -l` -gt 0 ]; then
+    TEST_PASSED=0
+    RESULT_COMMENT="RTS fatal"
+    ERROR_LEVEL=2
+elif [ `grep -E 'RTS err' <"$STDERR_FN" | wc -l` -gt 0 ]; then
+    TEST_PASSED=0
+    RESULT_COMMENT="RTS err"
+    ERROR_LEVEL=1
+elif [ $LAUNCH_EXIT_CODE -ne 0 ]; then
+    TEST_PASSED=0
+    RESULT_COMMENT="Launch failure"
+    ERROR_LEVEL=4
+else
+    TEST_PASSED=1
+    RESULT_COMMENT="OK"
+    ERROR_LEVEL=0
+fi

dvm/tools/tester/trunk/main/gen-report.sh

@@ -0,0 +1,348 @@
+#!/bin/bash
+# Bash is required due to usage of associative arrays
+
+MY_DIR=$(cd "$(dirname "$(which "$0")")" && pwd)
+SAVE_DIR=`pwd`
+
+TEST_SUITE="$1"
+RESULTS_DIR="$2"
+FULL_REP_URL="$3"
+REV_NUMBER=$4
+
+if [ -z "$FULL_REP_URL" ]; then
+    FULL_REP_URL="full-report.html"
+fi
+
+if [ -z "$REV_NUMBER" ]; then
+    REV_NUMBER=UNKNOWN
+fi
+
+MAX_LONELY_OK=50
+REPORT_DIR="$RESULTS_DIR/report"
+rm -rf "$REPORT_DIR"
+RES_FILES=`mktemp`
+find "$RESULTS_DIR" -mindepth 1 -type f | LC_ALL=C sort >$RES_FILES
+BUGGY_FILE_DIR="$REPORT_DIR/sources"
+mkdir -p "$BUGGY_FILE_DIR"
+REPORT_FILE="$REPORT_DIR/brief-report.html"
+FULL_REPORT_FILE="$REPORT_DIR/full-report.html"
+
+COL_COUNT=2
+PLATFORMS=
+HAS_SUBTESTS=0
+TOTAL_LAUNCHES=0
+TOTAL_ERROR_LAUNCHES=0
+
+while IFS= read -r f; do
+    CUR_DEPTH=0
+    TEST_SHORT_PATH=`basename "$f" .result`
+    TMPSTR=`dirname "$f"`
+    while [ "$TMPSTR" != "$RESULTS_DIR" ]; do
+        CUR_DEPTH=$(( $CUR_DEPTH + 1 ))
+        TEST_SHORT_PATH="$(basename "$TMPSTR")/$TEST_SHORT_PATH"
+        TMPSTR=`dirname "$TMPSTR"`
+    done
+    IS_SUBTEST=0
+    if [ ! -e "$TEST_SUITE/$TEST_SHORT_PATH" ]; then
+        HAS_SUBTESTS=1
+        IS_SUBTEST=1
+    fi
+    if [ $(( CUR_DEPTH + 2 )) -gt $COL_COUNT ]; then
+        COL_COUNT=$(( $CUR_DEPTH + 2 ))
+    fi
+    if [ $IS_SUBTEST -eq 0 ]; then
+        while IFS= read -r lin; do
+            eval $lin
+            if [ -z "$PLATFORMS" ]; then
+                PLATFORMS=$PLATFORM
+            else
+                FOUND_FLAG=0
+                for platf in $PLATFORMS; do
+                    if [ $platf = $PLATFORM ]; then
+                        FOUND_FLAG=1
+                    fi
+                done
+                if [ $FOUND_FLAG -eq 0 ]; then
+                    PLATFORMS="$PLATFORMS $PLATFORM"
+                fi
+            fi
+            TOTAL_LAUNCHES=$(( $TOTAL_LAUNCHES + 1 ))
+            if [ "$ERROR_LEVEL" != "0" ]; then
+                TOTAL_ERROR_LAUNCHES=$(( $TOTAL_ERROR_LAUNCHES + 1 ))
+            fi
+        done <"$f"
+    fi
+done <$RES_FILES
+
+CAT_COUNT=$(( COL_COUNT - 1 - HAS_SUBTESTS - 1 ))
+
+exec 5>"$REPORT_FILE"
+exec 6>"$FULL_REPORT_FILE"
+
+echo "<html>" >& 5
+echo "<html>" >& 6
+echo "<head>" >& 5
+echo "<head>" >& 6
+echo "<title>Test results for DVM-system. Revision $REV_NUMBER.</title>" >& 5
+echo "<title>Test results for DVM-system. Revision $REV_NUMBER.</title>" >& 6
+echo "<style>" >& 6
+cat "$MY_DIR/report.css" >& 6
+echo "</style>" >& 6
+echo "<script type='text/javascript'>" >& 6
+cat "$MY_DIR/report.js" >& 6
+echo "</script>" >& 6
+echo "</head>" >& 5
+echo "</head>" >& 6
+echo "<body>" >& 5
+echo "<body>" >& 6
+echo "<h1 align=center>Test results for DVM-system. Revision $REV_NUMBER.</h1>" >& 5
+echo "<h1 align=center>Test results for DVM-system. Revision $REV_NUMBER.</h1>" >& 6
+echo "<h2 align=center>Tested on platforms: $PLATFORMS.</h2>" >& 5
+echo "<h2 align=center>Tested on platforms: $PLATFORMS.</h2>" >& 6
+echo "<h3 align=center>Full report can be seen on <a href='$FULL_REP_URL'>$FULL_REP_URL</a></h3>" >& 5
+echo "<p align=center>Launches with errors: $TOTAL_ERROR_LAUNCHES / $TOTAL_LAUNCHES</p>" >& 5
+echo "<p align=center>Launches with errors: $TOTAL_ERROR_LAUNCHES / $TOTAL_LAUNCHES</p>" >& 6
+echo "<h3 align=center><a href='sources.tgz'>Download sources of buggy tests</a></h3>" >& 6
+echo "<table border=1 cellspacing=0 align=center>" >& 5
+echo "<table border=1 cellspacing=0 align=center>" >& 6
+echo "<tr>" >& 5
+echo "<tr>" >& 6
+CUR_COL=0
+while [ $CUR_COL -lt $CAT_COUNT ]; do
+    echo "<th align=center>Category</th>" >& 5
+    echo "<th>Category</th>" >& 6
+    CUR_COL=$(( CUR_COL + 1 ))
+done
+echo "<th align=center>Test name</th>" >& 5
+echo "<th>Test name</th>" >& 6
+if [ $HAS_SUBTESTS -ne 0 ]; then
+    echo "<th>Subtest</th>" >& 6
+fi
+echo "<th align=center>Test result</th>" >& 5
+echo "<th>Test result</th>" >& 6
+echo "</tr>" >& 5
+echo "</tr>" >& 6
+
+output_cat_recursive()
+{
+    if [ `basename "$1"` != "$1" ]; then
+        output_cat_recursive `dirname "$1"`
+    fi
+    if [ $TO_BRIEF -ne 0 ]; then
+        echo "<td align=center>" >& 5
+        basename "$1" >& 5
+        echo "</td>" >& 5
+    fi
+    echo "<td>" >& 6
+    basename "$1" >& 6
+    echo "</td>" >& 6
+    FILLED_COLS=$(( FILLED_COLS + 1 ))
+    if [ $FILLED_COLS -eq 1 -a `basename "$1"` = "Performance" ]; then
+        FORCE_TABLE=1
+    fi
+}
+
+output_cat()
+{
+    FILLED_COLS=0
+    output_cat_recursive "$1"
+    while [ $FILLED_COLS -lt $CAT_COUNT ]; do
+        if [ $TO_BRIEF -ne 0 ]; then
+            echo "<td>&nbsp;</td>" >& 5
+        fi
+        echo "<td>&nbsp;</td>" >& 6
+        FILLED_COLS=$(( FILLED_COLS + 1 ))
+    done
+}
+
+nextDetailsId=1
+
+while IFS= read -r f; do
+    CUR_DEPTH=0
+    TEST_SHORT_PATH=`basename "$f" .result`
+    TMPSTR=`dirname "$f"`
+    while [ "$TMPSTR" != "$RESULTS_DIR" ]; do
+        CUR_DEPTH=$(( $CUR_DEPTH + 1 ))
+        TEST_SHORT_PATH="$(basename "$TMPSTR")/$TEST_SHORT_PATH"
+        TMPSTR=`dirname "$TMPSTR"`
+    done
+    SUBTEST_NAME=
+    if [ ! -e "$TEST_SUITE/$TEST_SHORT_PATH" ]; then
+        SUBTEST_NAME=`basename "$TEST_SHORT_PATH"`
+        TEST_SHORT_PATH=`dirname "$TEST_SHORT_PATH"`
+    fi
+    HAS_FAILS=0
+    if [ `grep "TEST_PASSED=0" <"$f" | wc -l` -gt 0 ]; then
+        HAS_FAILS=1
+        if [ ! -e "$BUGGY_FILE_DIR/$TEST_SHORT_PATH" ]; then
+            mkdir -p `dirname "$BUGGY_FILE_DIR/$TEST_SHORT_PATH"`
+            cp -ur "$TEST_SUITE/$TEST_SHORT_PATH" "$BUGGY_FILE_DIR/$TEST_SHORT_PATH"
+        fi
+    fi
+    TO_BRIEF=1
+    if [ -n "$SUBTEST_NAME" -o $HAS_FAILS -eq 0 ]; then
+        TO_BRIEF=0
+    fi
+    if [ $TO_BRIEF -ne 0 ]; then
+        echo "<tr>" >& 5
+    fi
+    echo "<tr>" >& 6
+    FORCE_TABLE=0
+    output_cat `dirname "$TEST_SHORT_PATH"`
+    if [ $TO_BRIEF -ne 0 ]; then
+        echo "<td align=center>" >& 5
+        echo `basename "$TEST_SHORT_PATH"` >& 5
+        echo "</td>" >& 5
+    fi
+    if [ -n "$SUBTEST_NAME" ]; then
+        echo "<td>" >& 6
+        echo `basename "$TEST_SHORT_PATH"` >& 6
+        echo "</td>" >& 6
+        echo "<td>" >& 6
+        echo "$SUBTEST_NAME" >& 6
+        echo "</td>" >& 6
+    else
+        echo "<td colspan=$((1 + HAS_SUBTESTS))>" >& 6
+        echo `basename "$TEST_SHORT_PATH"` >& 6
+        echo "</td>" >& 6
+    fi
+    ERROR_LEVELS=$(
+    while IFS= read -r lin; do
+        eval $lin
+        if [ -z "$ERROR_LEVEL" ]; then
+            ERROR_LEVEL=0
+        fi
+        echo $ERROR_LEVEL
+    done <"$f" | sort -unr)
+    if [ $TO_BRIEF -ne 0 ]; then
+        echo "<td align=center>" >& 5
+    fi
+    echo "<td>" >& 6
+    LAUNCH_COUNT=`wc -l <"$f"`
+#    echo "$LAUNCH_COUNT total" >& 5
+#    echo "$LAUNCH_COUNT total" >& 6
+    if [ -n "$ERROR_LEVELS" ]; then
+        for el in $ERROR_LEVELS; do
+            unset countByComment
+            unset passedByComment
+            declare -A countByComment
+            declare -A passedByComment
+            while IFS= read -r lin; do
+                eval $lin
+                if [ -z "$ERROR_LEVEL" ]; then
+                    ERROR_LEVEL=0
+                fi
+                if [ "$ERROR_LEVEL" = "$el" ]; then
+                    if [ -z "${countByComment["$RESULT_COMMENT"]}" ]; then
+                        countByComment["$RESULT_COMMENT"]=0
+                    fi
+                    countByComment["$RESULT_COMMENT"]=$(( countByComment["$RESULT_COMMENT"] + 1 ))
+                    passedByComment["$RESULT_COMMENT"]=$TEST_PASSED
+                fi
+            done <"$f"
+            for cmt in "${!countByComment[@]}"; do
+                if [ ${passedByComment["$cmt"]} -ne 0 ]; then
+                    DIV_CLASS=passed
+                    DIV_COLOR=green
+                else
+                    DIV_CLASS=failed
+                    DIV_COLOR=red
+                fi
+                if [ $TO_BRIEF -ne 0 ]; then
+                    echo "<div style='color: $DIV_COLOR'>" >& 5
+                    echo "${countByComment[$cmt]} $cmt" >& 5
+                    echo "</div>" >& 5
+                fi
+                echo "<div class=$DIV_CLASS>" >& 6
+                if [ $HAS_FAILS -ne 0 -o $LAUNCH_COUNT -le $MAX_LONELY_OK -o $FORCE_TABLE -ne 0 ]; then
+                    echo "<a href='#' class='details $DIV_CLASS' onclick='{ toggleElem(\"det$nextDetailsId\"); return false; }'>" >& 6
+                    echo "<span class=details>${countByComment[$cmt]} $cmt</span>" >& 6
+                    echo "</a>" >& 6
+                    echo "<table border=1 cellspacing=0 class=details$FORCE_TABLE id='det$nextDetailsId'>" >& 6
+                    echo "<tr>" >& 6
+                    echo "<th>Platform</th>" >& 6
+                    echo "<th>noH</th>" >& 6
+                    echo "<th>autoTfm</th>" >& 6
+                    echo "<th>Grid</th>" >& 6
+                    echo "<th>CPUs</th>" >& 6
+                    echo "<th>GPUs</th>" >& 6
+                    echo "<th>Time</th>" >& 6
+                    echo "</tr>" >& 6
+                    while IFS= read -r lin; do
+                        eval $lin
+                        if [ -z "$ERROR_LEVEL" ]; then
+                            ERROR_LEVEL=0
+                        fi
+                        if [ "$ERROR_LEVEL" = "$el" -a "$RESULT_COMMENT" = "$cmt" ]; then
+                            echo "<tr>" >& 6
+                            echo "<td>$PLATFORM</td>" >& 6
+                            if [ $NOH_FLAG -ne 0 ]; then
+                                echo "<td>+</td>" >& 6
+                            else
+                                echo "<td>-</td>" >& 6
+                            fi
+                            if [ $AUTOTFM_FLAG -ne 0 ]; then
+                                echo "<td>+</td>" >& 6
+                            else
+                                echo "<td>-</td>" >& 6
+                            fi
+                            if [ -n "$PROC_GRID" ]; then
+                                echo "<td>$PROC_GRID</td>" >& 6
+                            else
+                                echo "<td>N/A</td>" >& 6
+                            fi
+                            if [ -n "$CPUS_PER_PROC" ]; then
+                                echo "<td>$CPUS_PER_PROC</td>" >& 6
+                            else
+                                echo "<td>N/A</td>" >& 6
+                            fi
+                            if [ -n "$CUDAS_PER_PROC" ]; then
+                                echo "<td>$CUDAS_PER_PROC</td>" >& 6
+                            else
+                                echo "<td>N/A</td>" >& 6
+                            fi
+                            if [ -n "$CALC_TIME" ]; then
+                                echo "<td>$CALC_TIME</td>" >& 6
+                            else
+                                echo "<td>N/A</td>" >& 6
+                            fi
+                            echo "</tr>" >& 6
+                        fi
+                    done <"$f"
+                    echo "</table>" >& 6
+                    nextDetailsId=$(( nextDetailsId + 1 ))
+                else
+                    echo "${countByComment[$cmt]} $cmt" >& 6
+                fi
+                echo "</div>" >& 6
+            done
+        done
+    else
+        if [ $TO_BRIEF -ne 0 ]; then
+            echo "&nbsp;" >& 5
+        fi
+        echo "&nbsp;" >& 6
+    fi
+    if [ $TO_BRIEF -ne 0 ]; then
+        echo "</td>" >& 5
+        echo "</tr>" >& 5
+    fi
+    echo "</td>" >& 6
+    echo "</tr>" >& 6
+done <$RES_FILES
+
+echo "</table>" >& 5
+echo "</table>" >& 6
+echo "</body>" >& 5
+echo "</body>" >& 6
+echo "</html>" >& 5
+echo "</html>" >& 6
+
+exec 5>&-
+exec 6>&-
+
+cd "$REPORT_DIR"
+tar -czf "sources.tgz" "sources"
+cd "$SAVE_DIR"
+
+rm $RES_FILES

dvm/tools/tester/trunk/main/machine-config.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+# Default
+# Assuming several identical processors and not counting HT cores
+CPUS_PER_NODE=$(( `cat /proc/cpuinfo | grep "cpu cores" | LC_ALL=C sort | uniq | awk '{ print $4 }'` * `cat /proc/cpuinfo | grep "physical id" | LC_ALL=C sort | uniq | wc -l` ))
+which nvidia-smi >/dev/null 2>& 1
+if [ $? -eq 0 ]; then
+    CUDAS_PER_NODE=`nvidia-smi -L 2>/dev/null | wc -l`
+else
+    CUDAS_PER_NODE=0
+fi
+
+# Specializations
+if [ `hostname` = "k100" ]; then
+    CPUS_PER_NODE=12
+    CUDAS_PER_NODE=3
+fi

dvm/tools/tester/trunk/main/perform-tests.sh

@@ -0,0 +1,352 @@
+#!/bin/bash
+# Bash is required due to usage of arrays
+
+SAVE_DIR=`pwd`
+MY_DIR=$(cd "$(dirname "$(which "$0")")" && pwd)
+
+DVMSYS_DIR="$1"
+TEST_SUITE="$2"
+TASK_PROCESSOR_FD=$3
+
+. "$MY_DIR/machine-config.sh"
+
+if [ -f "$SAVE_DIR/machine-config.sh" ]; then
+    . "$SAVE_DIR/machine-config.sh"
+fi
+
+. "$MY_DIR/test-utils.sh"
+
+PLATFORM_CMD=$(grep "PLATFORM=" <"$DVMSYS_DIR/bin/dvm_settings.sh" | sed -s 's/export //g')
+eval $PLATFORM_CMD
+
+SETTINGS_FILE=settings
+ANALYZER_FILE=test-analyzer.sh
+
+prepare_new_dir() {
+    local TASK_DIR
+    TASK_DIR=`mktemp -d`
+    local COMP_OPTS
+    COMP_OPTS="$1"
+    local COMPILE_PID
+    local COMPILE_RES
+    cd "$TASK_DIR"
+    echo "#!/bin/sh" >dvm
+    echo "export dvmarithmloopsize=1000000" >>dvm
+    echo "exec '$DVMSYS_DIR/bin/dvm_drv' \"\$@\"" >>dvm
+    chmod a+x dvm
+    cp "$DVMSYS_DIR/user/usr.par" ./
+    set -m
+    if [ -f "$TEST_FILE" ]; then
+        cp "$TEST_FILE" "$TEST_NAME"
+        ./dvm $LANG_COMP -shared-dvm $COMP_OPTS "$TEST_NAME" >"build.log" 2>& 1 &
+        COMPILE_PID=$!
+    else
+        find "$TEST_FILE" -mindepth 1 -maxdepth 1 | xargs cp -r -t .
+        PATH="$TASK_DIR:$PATH" ./compile.sh $COMP_OPTS >"build.log" 2>& 1 &
+        COMPILE_PID=$!
+    fi
+    proc_killer -$COMPILE_PID 600 &
+    KILLER_PID=$!
+    disown
+    wait $COMPILE_PID
+    COMPILE_RES=$?
+    kill -2 $KILLER_PID >/dev/null 2>& 1
+    kill -15 $KILLER_PID >/dev/null 2>& 1
+    kill -9 $KILLER_PID >/dev/null 2>& 1
+    if [ ! -f "$TEST_FILE" ] && [ $COMPILE_RES -eq 0 ] && [ ! -f "$TEST_EXENAME" ]; then
+        :> "$TEST_EXENAME"
+    fi
+    echo "$TASK_DIR"
+}
+
+do_test() {
+    TEST_FILE="$1"
+    TEST_NAME=`basename "$TEST_FILE"`
+    TEST_SHORT_PATH="$TEST_NAME"
+    TMPSTR=`dirname $TEST_FILE`
+    while [ "$TMPSTR" != "$TEST_SUITE" ]; do
+        TEST_SHORT_PATH="$(basename $TMPSTR)/$TEST_SHORT_PATH"
+        TMPSTR=`dirname $TMPSTR`
+    done
+    TEST_EXENAME="${TEST_NAME%.*}"
+    case ${TEST_NAME##*.} in
+        c|cdv) IS_FORTRAN=0;;
+        f|f90|fdv) IS_FORTRAN=1;;
+    esac
+    if [ $IS_FORTRAN -ne 0 ]; then
+        LANG_COMP="f"
+    else
+        LANG_COMP="c"
+    fi
+    TEST_DIMS=
+    if [ -n "$DIMENSION_COUNT" ]; then
+        TEST_DIMS=$DIMENSION_COUNT
+    else
+        for t in $DIMENSION_MAP; do
+            FN=`echo $t | sed 's/=/ /g' | awk '{print $1}'`
+            DIM=`echo $t | sed 's/=/ /g' | awk '{print $2}'`
+            if [ "$FN" = "$TEST_NAME" ]; then
+                TEST_DIMS=$DIM
+                break
+            fi
+        done
+    fi
+    if [ -z "$TEST_DIMS" ]; then
+        # Trying to extract dimension number from filename - it is first digit in it.
+        TEST_DIMS=`echo "$TEST_EXENAME" | sed 's/[^0-9]//g' | cut -c1`
+    fi
+    if [ -z "$TEST_DIMS" ]; then
+        echo "Can not find information about dimension count for test $TEST_FILE" >& 2
+        TEST_DIMS=1
+    fi
+    if [ $MAX_DIM_PROC_COUNT -le 0 ]; then
+        MAX_DIM_PROC_COUNT=$MAX_PROC_COUNT
+    fi
+    while true; do
+        if [ -f "$SAVE_DIR/dvm-tester.pause" ] && [ "$(cat "$SAVE_DIR/dvm-tester.pause")" = "Immediate" ]; then
+            echo "Paused explicitly (local)"
+        elif [ -f "$MY_DIR/dvm-tester.pause" ] && [ "$(cat "$MY_DIR/dvm-tester.pause")" = "Immediate" ]; then
+            echo "Paused explicitly (global)"
+        else
+            break
+        fi
+        sleep 60
+    done
+    echo "Compiling $TEST_SHORT_PATH on $PLATFORM platform"
+    if [ $GPU_ONLY -eq 0 ]; then
+        # Compile with noH
+        NOH_DIR=`prepare_new_dir "-noH"`
+        if [ -f "$NOH_DIR/$TEST_EXENAME" ]; then
+            ISSUE_NOH=1
+        else
+            ISSUE_NOH=0
+        fi
+    fi
+    if [ $DVM_ONLY -eq 0 ]; then
+        # Compile without noH
+        H_DIR=`prepare_new_dir ""`
+        if [ -f "$H_DIR/$TEST_EXENAME" ]; then
+            ISSUE_H=1
+        else
+            ISSUE_H=0
+        fi
+        # And with autoTfm
+        AUTOTFM_DIR=`prepare_new_dir "-autoTfm"`
+        if [ -f "$AUTOTFM_DIR/$TEST_EXENAME" ]; then
+            ISSUE_AUTOTFM=1
+        else
+            ISSUE_AUTOTFM=0
+        fi
+    fi
+#    cat "$H_DIR/build.log"
+    echo "Generating tasks for $TEST_SHORT_PATH with $TEST_DIMS dimensions on $PLATFORM platform"
+    COMMON_PART=$(
+        echo -n "TASK_TYPE=1"
+        echo -n " TEST_PLATFORM=$PLATFORM"
+        echo -n " SHARE_RESOURCES=$SHARE_RESOURCES"
+        echo -n " TEST_ANALYZER=\"$TEST_ANALYZER\""
+        echo -n " TEST_SHORT_PATH=\"$TEST_SHORT_PATH\""
+        echo -n " TASK_EXE=\"$TEST_EXENAME\""
+        echo -n " TEST_MAX_TIME=$MAX_TIME"
+    )
+    # Additional size number 0 added
+    i=0
+    while [ $i -le $TEST_DIMS ]; do
+        sizes[$i]=1
+        i=$(( i + 1 ))
+    done
+    counter=0
+    totalSize=1
+    while [ $(( sizes[0] )) -eq 1 ]; do
+        PROC_GRID=
+        if [ $IS_FORTRAN -eq 0 ]; then
+            i=1
+            while [ $i -le $TEST_DIMS ]; do
+                PROC_GRID="$PROC_GRID $((sizes[i]))"
+                i=$(( i + 1 ))
+            done
+        else
+            i=$TEST_DIMS
+            while [ $i -ge 1 ]; do
+                PROC_GRID="$PROC_GRID $((sizes[i]))"
+                i=$(( i - 1 ))
+            done
+        fi
+        if [ $GPU_ONLY -eq 0 ]; then
+            if [ $ISSUE_NOH -ne 0 ]; then
+                echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+                echo -n " TASK_DIR=\"$NOH_DIR\"" >&$TASK_PROCESSOR_FD
+                echo -n " TASK_NOH_FLAG=1" >&$TASK_PROCESSOR_FD
+                echo -n " CPUS_PER_PROC=1" >&$TASK_PROCESSOR_FD
+                echo -n " PROC_GRID=\"$PROC_GRID\"" >&$TASK_PROCESSOR_FD
+                counter=$(( counter + 1 ))
+                echo >&$TASK_PROCESSOR_FD
+            fi
+        fi
+        if [ $DVM_ONLY -eq 0 ]; then
+            # Single-device and single-threaded configurations
+            if [ $GPU_ONLY -eq 0 ]; then
+                if [ $ISSUE_H -ne 0 ]; then
+                    echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+                    echo -n " TASK_DIR=\"$H_DIR\"" >&$TASK_PROCESSOR_FD
+                    echo -n " CPUS_PER_PROC=1" >&$TASK_PROCESSOR_FD
+                    echo -n " PROC_GRID=\"$PROC_GRID\"" >&$TASK_PROCESSOR_FD
+                    counter=$(( counter + 1 ))
+                    echo >&$TASK_PROCESSOR_FD
+                fi
+            fi
+            if [ $CUDAS_PER_NODE -gt 0 ]; then
+                if [ $ISSUE_H -ne 0 ]; then
+                    echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+                    echo -n " TASK_DIR=\"$H_DIR\"" >&$TASK_PROCESSOR_FD
+                    echo -n " CUDAS_PER_PROC=1" >&$TASK_PROCESSOR_FD
+                    echo -n " PROC_GRID=\"$PROC_GRID\"" >&$TASK_PROCESSOR_FD
+                    counter=$(( counter + 1 ))
+                    echo >&$TASK_PROCESSOR_FD
+                fi
+                if [ $ISSUE_AUTOTFM -ne 0 ]; then
+                    echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+                    echo -n " TASK_DIR=\"$AUTOTFM_DIR\"" >&$TASK_PROCESSOR_FD
+                    echo -n " TASK_AUTOTFM_FLAG=1" >&$TASK_PROCESSOR_FD
+                    echo -n " CUDAS_PER_PROC=1" >&$TASK_PROCESSOR_FD
+                    echo -n " PROC_GRID=\"$PROC_GRID\"" >&$TASK_PROCESSOR_FD
+                    counter=$(( counter + 1 ))
+                    echo >&$TASK_PROCESSOR_FD
+                fi
+            fi
+            # Multi-device and multi-threaded configurations
+            MAX_DEVS_PER_PROC=$((sizes[1]))
+            DEVS_PER_PROC=2
+            while [ $DEVS_PER_PROC -le $MAX_DEVS_PER_PROC ]; do
+                if [ $(( MAX_DEVS_PER_PROC % DEVS_PER_PROC )) -ne 0 ]; then
+                    DEVS_PER_PROC=$(( $DEVS_PER_PROC + 1 ))
+                    continue
+                fi
+                if [ $IS_FORTRAN -eq 0 ]; then
+                    MD_PROC_GRID=" $((MAX_DEVS_PER_PROC / DEVS_PER_PROC))"
+                    i=2
+                    while [ $i -le $TEST_DIMS ]; do
+                        MD_PROC_GRID="$MD_PROC_GRID $((sizes[i]))"
+                        i=$(( i + 1 ))
+                    done
+                else
+                    MD_PROC_GRID=
+                    i=$TEST_DIMS
+                    while [ $i -ge 2 ]; do
+                        MD_PROC_GRID="$MD_PROC_GRID $((sizes[i]))"
+                        i=$(( i - 1 ))
+                    done
+                    MD_PROC_GRID="$MD_PROC_GRID $((MAX_DEVS_PER_PROC / DEVS_PER_PROC))"
+                fi
+                if [ $GPU_ONLY -eq 0 ]; then
+                    if [ $ISSUE_H -ne 0 ]; then
+                        echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+                        echo -n " TASK_DIR=\"$H_DIR\"" >&$TASK_PROCESSOR_FD
+                        echo -n " CPUS_PER_PROC=$DEVS_PER_PROC" >&$TASK_PROCESSOR_FD
+                        echo -n " PROC_GRID=\"$MD_PROC_GRID\"" >&$TASK_PROCESSOR_FD
+                        counter=$(( counter + 1 ))
+                        echo >&$TASK_PROCESSOR_FD
+                    fi
+                fi
+                if [ $ALLOW_MULTIDEV -ne 0 ] && [ $CUDAS_PER_NODE -gt 0 ]; then
+                    for ((GPUS_PER_PROC=1; GPUS_PER_PROC<=$DEVS_PER_PROC; GPUS_PER_PROC++)); do
+                        if [ $ISSUE_H -ne 0 ]; then
+                            echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+                            echo -n " TASK_DIR=\"$H_DIR\"" >&$TASK_PROCESSOR_FD
+                            echo -n " CPUS_PER_PROC=$(($DEVS_PER_PROC - $GPUS_PER_PROC))" >&$TASK_PROCESSOR_FD
+                            echo -n " CUDAS_PER_PROC=$GPUS_PER_PROC" >&$TASK_PROCESSOR_FD
+                            echo -n " PROC_GRID=\"$MD_PROC_GRID\"" >&$TASK_PROCESSOR_FD
+                            counter=$(( counter + 1 ))
+                            echo >&$TASK_PROCESSOR_FD
+                        fi
+                        if [ $ISSUE_AUTOTFM -ne 0 ]; then
+                            echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+                            echo -n " TASK_DIR=\"$AUTOTFM_DIR\"" >&$TASK_PROCESSOR_FD
+                            echo -n " TASK_AUTOTFM_FLAG=1" >&$TASK_PROCESSOR_FD
+                            echo -n " CPUS_PER_PROC=$(($DEVS_PER_PROC - $GPUS_PER_PROC))" >&$TASK_PROCESSOR_FD
+                            echo -n " CUDAS_PER_PROC=$GPUS_PER_PROC" >&$TASK_PROCESSOR_FD
+                            echo -n " PROC_GRID=\"$MD_PROC_GRID\"" >&$TASK_PROCESSOR_FD
+                            counter=$(( counter + 1 ))
+                            echo >&$TASK_PROCESSOR_FD
+                        fi
+                    done
+                fi
+                DEVS_PER_PROC=$(( $DEVS_PER_PROC + 1 ))
+            done
+        fi
+        # Advance to next configuration
+        i=$TEST_DIMS
+        while [ $i -ge 0 ]; do
+            sizes[$i]=$(( sizes[i] + 1 ))
+            totalSize=1
+            j=1
+            while [ $j -le $TEST_DIMS ]; do
+                totalSize=$(( totalSize * sizes[j] ))
+                j=$(( j + 1 ))
+            done
+            if [ $(( sizes[i] )) -le $MAX_DIM_PROC_COUNT -a $totalSize -le $MAX_PROC_COUNT ]; then
+                break
+            elif [ $i -gt 0 ]; then
+                sizes[$i]=1
+            fi
+            i=$(( i - 1 ))
+        done
+    done
+    echo "Generated $counter tasks"
+    COMMON_PART=$(
+        echo -n "TASK_TYPE=0"
+        echo -n " TEST_PLATFORM=$PLATFORM"
+        echo -n " TEST_SHORT_PATH=\"$TEST_SHORT_PATH\""
+        echo -n " TASK_EXE=\"$TEST_EXENAME\""
+    )
+    if [ $GPU_ONLY -eq 0 ]; then
+        echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+        echo -n " TASK_DIR=\"$NOH_DIR\"" >&$TASK_PROCESSOR_FD
+        echo -n " TASK_NOH_FLAG=1" >&$TASK_PROCESSOR_FD
+        echo >&$TASK_PROCESSOR_FD
+    fi
+    if [ $DVM_ONLY -eq 0 ]; then
+        echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+        echo -n " TASK_DIR=\"$H_DIR\"" >&$TASK_PROCESSOR_FD
+        echo >&$TASK_PROCESSOR_FD
+        echo -n "$COMMON_PART" >&$TASK_PROCESSOR_FD
+        echo -n " TASK_DIR=\"$AUTOTFM_DIR\"" >&$TASK_PROCESSOR_FD
+        echo -n " TASK_AUTOTFM_FLAG=1" >&$TASK_PROCESSOR_FD
+        echo >&$TASK_PROCESSOR_FD
+    fi
+}
+
+traverse_tests() {
+    CUR_DIR="$1"
+    if [ -f "$CUR_DIR/$SETTINGS_FILE" ]; then
+        . "$CUR_DIR/$SETTINGS_FILE"
+    fi
+    if [ -f "$CUR_DIR/$ANALYZER_FILE" ]; then
+        TEST_ANALYZER="$CUR_DIR/$ANALYZER_FILE"
+    fi
+    TESTS=`mktemp`
+    find "$CUR_DIR" -mindepth 1 -maxdepth 1 -regex '.*[.]\(c\|cdv\|f\|f90\|fdv\)' | LC_ALL=C sort >$TESTS
+    DIRS=`mktemp`
+    find "$CUR_DIR" -mindepth 1 -maxdepth 1 -type d -regex '.*/[^.]*' | LC_ALL=C sort >$DIRS
+    while IFS= read -r f; do
+        ( do_test "$f" )
+    done <$TESTS
+    while IFS= read -r d; do
+        ( traverse_tests "$d" )
+    done <$DIRS
+    rm $DIRS $TESTS
+}
+
+set_default_settings() {
+    MAX_PROC_COUNT=1
+    MAX_DIM_PROC_COUNT=0
+    SHARE_RESOURCES=0
+    ALLOW_MULTIDEV=1
+    DVM_ONLY=0
+    GPU_ONLY=0
+    TEST_ANALYZER="$MY_DIR/default-test-analyzer.sh"
+    MAX_TIME=300
+}
+
+set_default_settings
+(traverse_tests "$TEST_SUITE")

dvm/tools/tester/trunk/main/report.css

@@ -0,0 +1,24 @@
+th, td {
+    text-align: center;
+}
+div.passed, a.passed {
+    color: green;
+}
+div.failed, a.failed {
+    color: red;
+}
+a.details {
+    text-decoration: none;
+    font-size: 50%;
+    border-bottom: 1px dashed;
+}
+span.details {
+    font-size: 200%;
+    line-height: normal;
+}
+table.details0 {
+    display: none;
+}
+table.details1 {
+    display: block;
+}

dvm/tools/tester/trunk/main/report.js

@@ -0,0 +1,7 @@
+function toggleElem(id) {
+    var e = document.getElementById(id);
+    if(e.style.display == 'block')
+        e.style.display = 'none';
+    else
+        e.style.display = 'block';
+}

dvm/tools/tester/trunk/main/task-processor.sh

@@ -0,0 +1,366 @@
+#!/bin/bash
+# Bash is required due to usage of 'disown' command
+
+SAVE_DIR=`pwd`
+MY_DIR=$(cd "$(dirname "$(which "$0")")" && pwd)
+
+RESULTS_DIR="$1"
+
+. "$MY_DIR/machine-config.sh"
+
+if [ -f "$SAVE_DIR/machine-config.sh" ]; then
+    . "$SAVE_DIR/machine-config.sh"
+fi
+
+. "$MY_DIR/configure-run.sh"
+
+if [ -f "$SAVE_DIR/configure-run.sh" ]; then
+    . "$SAVE_DIR/configure-run.sh"
+fi
+
+. "$MY_DIR/test-utils.sh"
+
+if [ $INTERACTIVE -ne 0 ]; then
+    stdout_fn() {
+        echo "$1.stdout"
+    }
+    stderr_fn() {
+        echo "$1.stderr"
+    }
+fi
+
+if [ $HAS_RES_MANAGER -eq 0 ]; then
+    RES_MAN_DIR=`mktemp -d`
+fi
+
+resources_freed() {
+    FN=`mktemp`
+    if [ $SHARE_RESOURCES -eq 0 ]; then
+        FREED_CPUS=$(( CPUS_PER_NODE * MAX_CPU_SHARING_FACTOR ))
+        FREED_CUDAS=$(( CUDAS_PER_NODE * MAX_CUDA_SHARING_FACTOR ))
+    else
+        FREED_CPUS=$(( totalProcs * CPUS_PER_PROC ))
+        FREED_CUDAS=$(( totalProcs * CUDAS_PER_PROC ))
+    fi
+    echo "FREED_CPUS=$FREED_CPUS" >>$FN
+    echo "FREED_CUDAS=$FREED_CUDAS" >>$FN
+#    echo "rm $FN" >>$FN
+    mv $FN $RES_MAN_DIR/
+}
+
+interactive_launcher() {
+    cd "$LAUNCH_DIR"
+    STDOUT_FN=`stdout_fn "$LAUNCH_NAME"`
+    STDERR_FN=`stderr_fn "$LAUNCH_NAME"`
+    :>$STDOUT_FN
+    :>$STDERR_FN
+    set -m
+#    echo ./dvm run $PROC_GRID "$TASK_EXE"
+    START_T=`date +%s`
+    if [ -f "run.sh" ]; then
+        PATH="$LAUNCH_DIR:$PATH" PROC_GRID="$PROC_GRID" DVMH_PPN=$LAUNCH_PPN DVMH_NUM_THREADS=$CPUS_PER_PROC DVMH_NUM_CUDAS=$CUDAS_PER_PROC ./run.sh </dev/null >"$STDOUT_FN" 2>"$STDERR_FN" &
+        LAUNCH_PID=$!
+    else
+        DVMH_PPN=$LAUNCH_PPN DVMH_NUM_THREADS=$CPUS_PER_PROC DVMH_NUM_CUDAS=$CUDAS_PER_PROC ./dvm run $PROC_GRID "$TASK_EXE" </dev/null >"$STDOUT_FN" 2>"$STDERR_FN" &
+        LAUNCH_PID=$!
+    fi
+    if [ $TEST_MAX_TIME -gt 0 ]; then
+#        echo "Setting proc_killer to process $LAUNCH_PID for $TEST_MAX_TIME"
+        proc_killer -$LAUNCH_PID $TEST_MAX_TIME </dev/null >/dev/null 2>& 1 &
+        KILLER_PID=$!
+        disown
+    fi
+    wait $LAUNCH_PID
+    START_RES=$?
+    END_T=`date +%s`
+    CALC_TIME=$(( END_T - START_T ))
+    if [ $TEST_MAX_TIME -gt 0 ]; then
+        kill -2 $KILLER_PID >/dev/null 2>& 1
+        kill -15 $KILLER_PID >/dev/null 2>& 1
+        kill -9 $KILLER_PID >/dev/null 2>& 1
+    fi
+    if [ $HAS_RES_MANAGER -eq 0 ]; then
+        resources_freed
+    fi
+    echo "$START_RES $CALC_TIME" >"$TASK_EXE.finished"
+}
+
+non_interactive_launcher() {
+    cd "$LAUNCH_DIR"
+    STDOUT_FN=`mktemp`
+    STDERR_FN=`mktemp`
+#    echo ./dvm run $PROC_GRID "$TASK_EXE"
+    if [ $TEST_MAX_TIME -gt 0 ]; then
+        export maxtime=$(( (TEST_MAX_TIME + 59) / 60))
+    fi
+    if [ -f "run.sh" ]; then
+        PATH="$LAUNCH_DIR:$PATH" PROC_GRID="$PROC_GRID" DVMH_PPN=$LAUNCH_PPN DVMH_NUM_THREADS=$CPUS_PER_PROC DVMH_NUM_CUDAS=$CUDAS_PER_PROC ./run.sh >$STDOUT_FN 2>$STDERR_FN
+        START_RES=$?
+    else
+        DVMH_PPN=$LAUNCH_PPN DVMH_NUM_THREADS=$CPUS_PER_PROC DVMH_NUM_CUDAS=$CUDAS_PER_PROC ./dvm run $PROC_GRID "$TASK_EXE" >$STDOUT_FN 2>$STDERR_FN
+        START_RES=$?
+    fi
+    unset maxtime
+    :>"$TASK_EXE.committed"
+    IS_LAUNCHED=`is_launched $STDOUT_FN $STDERR_FN`
+    rm $STDOUT_FN $STDERR_FN
+    if [ $START_RES -eq 0 -a $IS_LAUNCHED -ne 0 ]; then
+        while [ `is_finished "$LAUNCH_NAME"` -eq 0 ]; do
+            sleep 1
+        done
+        CALC_TIME=`get_elapsed_time "$LAUNCH_NAME"`
+    fi
+    if [ $HAS_RES_MANAGER -eq 0 ]; then
+        resources_freed
+    fi
+    echo "$START_RES $CALC_TIME" >"$TASK_EXE.finished"
+}
+
+already_analyzed() {
+#    echo -n "PLATFORM=\"$TEST_PLATFORM\""
+#    echo -n " NOH_FLAG=$TASK_NOH_FLAG"
+#    echo -n " AUTOTFM_FLAG=$TASK_AUTOTFM_FLAG"
+#    echo -n " PROC_GRID=\"$PROC_GRID\""
+#    echo -n " CPUS_PER_PROC=$CPUS_PER_PROC"
+#    echo -n " CUDAS_PER_PROC=$CUDAS_PER_PROC"
+    local res
+    res=0
+    if [ -f "$RESULTS_DIR/$TEST_SHORT_PATH.result" ]; then
+        if [ $( cat "$RESULTS_DIR/$TEST_SHORT_PATH.result" | grep "PLATFORM=\"$TEST_PLATFORM\"" | grep "NOH_FLAG=$TASK_NOH_FLAG" | grep "AUTOTFM_FLAG=$TASK_AUTOTFM_FLAG" | grep "PROC_GRID=\"$PROC_GRID\"" | grep "CPUS_PER_PROC=$CPUS_PER_PROC" | grep "CUDAS_PER_PROC=$CUDAS_PER_PROC" | wc -l ) -gt 0 ]; then
+            res=1
+        fi
+    fi
+    echo $res
+}
+
+launcher() {
+    counter=0
+    if [ $HAS_RES_MANAGER -eq 0 ]; then
+        if [ $MAX_NODES_PER_TASK -gt 1 ]; then
+            echo "Can manage resources only for one-node system"
+            MAX_NODES_PER_TASK=1
+        fi
+        FREE_CPUS=$(( CPUS_PER_NODE * MAX_CPU_SHARING_FACTOR ))
+        FREE_CUDAS=$(( CUDAS_PER_NODE * MAX_CUDA_SHARING_FACTOR ))
+    fi
+    exec 4>$1
+    while IFS= read -r TASK_SPEC; do
+        TEST_PLATFORM=Unknown
+        TASK_NOH_FLAG=0
+        TASK_AUTOTFM_FLAG=0
+        PROC_GRID=0
+        CPUS_PER_PROC=0
+        CUDAS_PER_PROC=0
+        eval $TASK_SPEC
+        LAUNCHED_FLAG=0
+        ALREADY_ANALYZED=$( already_analyzed )
+        if [ $TASK_TYPE -eq 1 -a $ALREADY_ANALYZED -eq 0 ]; then
+            CAN_CPUS=$CPUS_PER_NODE
+            CAN_CUDAS=$CUDAS_PER_NODE
+            if [ $SHARE_RESOURCES -ne 0 ]; then
+                CAN_CPUS=$(( CAN_CPUS * MAX_CPU_SHARING_FACTOR ))
+                CAN_CUDAS=$(( CAN_CUDAS * MAX_CUDA_SHARING_FACTOR ))
+            fi
+            LAUNCH_PPN=$MAX_PPN
+            CUR_PPN=$LAUNCH_PPN
+            if [ $CPUS_PER_PROC -gt 0 ]; then
+                CUR_PPN=$(( CAN_CPUS / $CPUS_PER_PROC ))
+            fi
+            if [ $CUR_PPN -lt $LAUNCH_PPN ]; then
+                LAUNCH_PPN=$CUR_PPN
+            fi
+            if [ $CUDAS_PER_PROC -gt 0 ]; then
+                CUR_PPN=$(( CAN_CUDAS / $CUDAS_PER_PROC ))
+            fi
+            if [ $CUR_PPN -lt $LAUNCH_PPN ]; then
+                LAUNCH_PPN=$CUR_PPN
+            fi
+            totalProcs=1
+            for proc in $PROC_GRID; do
+                totalProcs=$(( totalProcs * proc ))
+            done
+            if [ $LAUNCH_PPN -gt 0 ]; then
+                USE_NODES=$(( ( totalProcs + LAUNCH_PPN - 1 ) / LAUNCH_PPN ))
+            else
+                LAUNCH_PPN=1
+                USE_NODES=$(( MAX_NODES_PER_TASK + 1 ))
+            fi
+            NEED_CPUS=$(( totalProcs * CPUS_PER_PROC ))
+            NEED_CUDAS=$(( totalProcs * CUDAS_PER_PROC ))
+            if [ $USE_NODES -le $MAX_NODES_PER_TASK ]; then
+                # Launch
+                counter=$(( counter + 1 ))
+                LAUNCH_DIR=`mktemp -d`
+                cp -r $TASK_DIR/* $LAUNCH_DIR/
+                TASK_SPEC=$( echo -n "$TASK_SPEC" ;  echo " LAUNCH_DIR=\"$LAUNCH_DIR\"" )
+                if [ $HAS_RES_MANAGER -eq 0 ]; then
+                    LAUNCH_NAME="$LAUNCH_DIR/$TASK_EXE"
+                else
+                    LAUNCH_NAME="$LAUNCH_DIR/$TASK_EXE.$totalProcs.1"
+                fi
+                TASK_SPEC=$( echo -n "$TASK_SPEC" ; echo " LAUNCH_NAME=\"$LAUNCH_NAME\"" )
+                while true; do
+                    if [ -f "$SAVE_DIR/dvm-tester.pause" ] && [ "$(cat "$SAVE_DIR/dvm-tester.pause")" = "Immediate" ]; then
+                        :
+                    elif [ -f "$MY_DIR/dvm-tester.pause" ] && [ "$(cat "$MY_DIR/dvm-tester.pause")" = "Immediate" ]; then
+                        :
+                    else
+                        break
+                    fi
+                    sleep 60
+                done
+                if [ $HAS_RES_MANAGER -ne 0 ]; then
+                    while [ `can_launch` -eq 0 ]; do
+                        sleep 1
+                    done
+                else
+                    if [ $SHARE_RESOURCES -eq 0 ]; then
+                        NEED_CPUS=$(( CPUS_PER_NODE * MAX_CPU_SHARING_FACTOR ))
+                        NEED_CUDAS=$(( CUDAS_PER_NODE * MAX_CUDA_SHARING_FACTOR ))
+                    fi
+                    cd "$RES_MAN_DIR"
+                    while [ $FREE_CPUS -lt $NEED_CPUS -o $FREE_CUDAS -lt $NEED_CUDAS ]; do
+                        FOUND_SMTH=0
+                        for f in `ls`; do
+                            FREED_CPUS=
+                            FREED_CUDAS=
+                            . ./$f
+                            if [ -n "$FREED_CPUS" -a -n "$FREED_CUDAS" ]; then
+                                FOUND_SMTH=1
+                                FREE_CPUS=$(( FREE_CPUS + FREED_CPUS ))
+                                FREE_CUDAS=$(( FREE_CUDAS + FREED_CUDAS ))
+                                rm $f
+                            fi
+                        done
+                        if [ $FOUND_SMTH -eq 0 ]; then
+                            sleep 1
+                        fi
+                    done
+                    FREE_CPUS=$(( FREE_CPUS - NEED_CPUS ))
+                    FREE_CUDAS=$(( FREE_CUDAS - NEED_CUDAS ))
+                fi
+                # Actually launch
+                if [ $INTERACTIVE -ne 0 ]; then
+                    interactive_launcher &
+                else
+                    non_interactive_launcher &
+                    if [ $HAS_RES_MANAGER -ne 0 ]; then
+                        while [ ! -f "$LAUNCH_DIR/$TASK_EXE.committed" ]; do
+                            sleep 1
+                        done
+                    fi
+                fi
+                LAUNCHED_FLAG=1
+            else
+                # Can not launch such big task
+                echo "Discarding too big task: $TASK_SPEC"
+            fi
+        elif [ $TASK_TYPE -eq 0 ]; then
+            LAUNCHED_FLAG=1
+        else
+            echo "Discarding task: $TASK_SPEC"
+        fi
+        if [ $LAUNCHED_FLAG -ne 0 ]; then
+            echo "$TASK_SPEC" >& 4
+        fi
+    done
+    echo ":" >& 4
+    exec 4>&-
+    echo "Total tasks launched: $counter"
+}
+
+print_result_line() {
+    echo -n "PLATFORM=\"$TEST_PLATFORM\""
+    echo -n " NOH_FLAG=$TASK_NOH_FLAG"
+    echo -n " AUTOTFM_FLAG=$TASK_AUTOTFM_FLAG"
+    echo -n " PROC_GRID=\"$PROC_GRID\""
+    echo -n " CPUS_PER_PROC=$CPUS_PER_PROC"
+    echo -n " CUDAS_PER_PROC=$CUDAS_PER_PROC"
+    echo -n " CALC_TIME=$TASK_CALC_TIME"
+    echo -n " TEST_PASSED=$TEST_PASSED"
+    echo -n " RESULT_COMMENT=\"$RESULT_COMMENT\""
+    echo " ERROR_LEVEL=$ERROR_LEVEL"
+}
+
+analyzer() {
+    counter=0
+    FIFO_NAME="$1"
+    while IFS= read -r TASK_SPEC; do
+        if [ "$TASK_SPEC" = ":" ]; then
+            break
+        fi
+        CPUS_PER_PROC=0
+        CUDAS_PER_PROC=0
+        TASK_NOH_FLAG=0
+        TASK_AUTOTFM_FLAG=0
+        eval $TASK_SPEC
+        if [ $TASK_TYPE -eq 0 ]; then
+            if [ ! -f "$TASK_DIR/$TASK_EXE" ]; then
+                # Report compilation error
+                if [ `basename "$TEST_SHORT_PATH"` != "$TEST_SHORT_PATH" ]; then
+                    mkdir -p "$RESULTS_DIR/$(dirname "$TEST_SHORT_PATH")"
+                fi
+                PROC_GRID=
+                CPUS_PER_PROC=
+                CUDAS_PER_PROC=
+                TASK_CALC_TIME=
+                TEST_PASSED=0
+                RESULT_COMMENT="Compilation error"
+                ERROR_LEVEL=255
+                print_result_line >>"$RESULTS_DIR/$TEST_SHORT_PATH.result"
+            fi
+            # Cleanup all the test's stuff
+            rm -rf "$TASK_DIR"
+        else
+            counter=$(( counter + 1 ))
+            cd "$LAUNCH_DIR"
+            while [ ! -f "$TASK_EXE.finished" ]; do
+                sleep 1
+            done
+            read LAUNCH_EXIT_CODE TASK_CALC_TIME <"$TASK_EXE.finished"
+            STDOUT_FN=`stdout_fn "$LAUNCH_NAME"`
+            STDERR_FN=`stderr_fn "$LAUNCH_NAME"`
+            SUBTEST_COUNT=0
+            . $TEST_ANALYZER
+            if [ `basename "$TEST_SHORT_PATH"` != "$TEST_SHORT_PATH" ]; then
+                mkdir -p "$RESULTS_DIR/$(dirname "$TEST_SHORT_PATH")"
+            fi
+            print_result_line >>"$RESULTS_DIR/$TEST_SHORT_PATH.result"
+            if [ $SUBTEST_COUNT -gt 0 ]; then
+                mkdir -p $RESULTS_DIR/$TEST_SHORT_PATH
+                for i in `seq $SUBTEST_COUNT`; do
+                    SUBTEST_NAME=$i
+                    analyze_subtest $i
+                    print_result_line >>"$RESULTS_DIR/$TEST_SHORT_PATH/$SUBTEST_NAME.result"
+                done
+            fi
+#            if [ $LAUNCH_EXIT_CODE -ne 0 -o "$RESULT_COMMENT" = "Crash" ]; then
+#                echo "Test's $TEST_SHORT_PATH stdout:"
+#                cat "$STDOUT_FN"
+#                echo "Test's $TEST_SHORT_PATH stderr:"
+#                cat "$STDERR_FN"
+#            fi
+            rm -rf "$LAUNCH_DIR"
+        fi
+    done <$FIFO_NAME
+    echo "Total tasks analyzed: $counter"
+}
+
+FIFO_NAME="$(mktemp -u).launch-fifo"
+mkfifo $FIFO_NAME
+
+analyzer $FIFO_NAME &
+launcher $FIFO_NAME
+
+wait
+
+rm $FIFO_NAME
+
+if [ $HAS_RES_MANAGER -eq 0 ]; then
+    cd "$RES_MAN_DIR"
+    for f in `ls`; do
+        . ./$f
+    done
+    cd "$SAVE_DIR"
+    rm -rf "$RES_MAN_DIR"
+fi

dvm/tools/tester/trunk/main/test-system.sh

@@ -0,0 +1,103 @@
+#!/bin/sh
+
+unset CDPATH
+
+SAVE_DIR=`pwd`
+MY_DIR=$(cd "$(dirname "$(which "$0")")" && pwd)
+
+DVMSYS_DIR=
+if [ -f ./dvm ]; then
+    DVMSYS_DIR_CMD="DVMSYS_DIR=$(grep 'dvmdir=' <./dvm | sed -s 's/export //g' | sed -s 's/dvmdir=//g')"
+    eval $DVMSYS_DIR_CMD
+fi
+TEST_SUITE=test-suite
+RESULTS_DIR=
+APPEND_RESULTS=0
+
+parse_params() {
+    while [ -n "$1" ]; do
+        if [ "$1" = "--dvm_sys" ]; then
+            DVMSYS_DIR="$2"
+            shift
+        elif [ "$1" = "--test-suite" ]; then
+            TEST_SUITE="$2"
+            shift
+        elif [ "$1" = "--append-results" ]; then
+            APPEND_RESULTS=1
+            RESULTS_DIR="$2"
+            shift
+        else
+            echo "Unknown option '$1'"
+            exit 1
+        fi
+        shift
+    done
+}
+
+parse_params $@ || exit 1
+
+# Check settings
+cd "$SAVE_DIR"
+if [ ! -d "$DVMSYS_DIR" -o ! -d "$DVMSYS_DIR/user" -o ! -f "$DVMSYS_DIR/user/dvm" -o ! -d "$TEST_SUITE" ]; then
+    MY_NAME=`basename "$0"`
+    echo "Usage: $0 [<options>]"
+    echo "    --dvm_sys     Directory of already installed DVM-system. Note that it is a directory, which contains directory 'user' directly. Usually it is .../dvm_current/dvm_sys. By default $MY_NAME searches for 'dvm' file in current directory and makes attempt to use its DVM-system"
+    echo "    --test-suite  Directory with test suite, which is formed in special way. By default 'test-suite' directory is used."
+    echo "    --append-results  Directory with partial results, which will be appended. By default new directory will be created."
+    echo "Exiting"
+    exit 1
+fi
+
+# Make them global paths
+DVMSYS_DIR=$(cd "$DVMSYS_DIR" && pwd)
+TEST_SUITE=$(cd "$TEST_SUITE" && pwd)
+
+if [ $APPEND_RESULTS -eq 0 ]; then
+    RESULTS_DIR="$SAVE_DIR/$(basename "$TEST_SUITE").results"
+else
+    RESULTS_DIR=$(cd "$RESULTS_DIR" && pwd)
+fi
+export TMPDIR="$SAVE_DIR/$(basename "$TEST_SUITE").work"
+if [ -d "/home/scratch" ]; then
+    TEMPL_NAME="/home/scratch/$(basename "$TMPDIR").XXX"
+    TMPDIR=$(mktemp -d "$TEMPL_NAME")
+fi
+mkdir -p "$TMPDIR"
+
+# Launch task processor
+TASK_FIFO="$(mktemp -u).task-fifo"
+mkfifo "$TASK_FIFO"
+if [ $APPEND_RESULTS -eq 0 ]; then
+    if [ -e "$RESULTS_DIR" ]; then
+        echo -n "$RESULTS_DIR already exists. Do you want to rewrite it (Y/n)? "
+        ans=n
+        read ans
+        if [ "$ans" != "y" -a "$ans" != "Y" ]; then
+            echo "Exiting"
+            exit 1
+        fi
+    fi
+    rm -rf "$RESULTS_DIR"
+fi
+mkdir -p "$RESULTS_DIR"
+cd "$SAVE_DIR"
+"$MY_DIR/task-processor.sh" "$RESULTS_DIR" <"$TASK_FIFO" &
+
+# Sequentially feed task processor from our test-suite
+exec 4>"$TASK_FIFO"
+cd "$SAVE_DIR"
+"$MY_DIR/perform-tests.sh" "$DVMSYS_DIR" "$TEST_SUITE" 4
+exec 4>&-
+
+# Wait for task processor to finish
+wait
+
+# Cleanup stuff
+rm "$TASK_FIFO"
+
+# Generate final report
+cd "$SAVE_DIR"
+"$MY_DIR/gen-report.sh" "$TEST_SUITE" "$RESULTS_DIR"
+
+echo "Results can be seen in $RESULTS_DIR directory"
+rm -rf "$TMPDIR"

dvm/tools/tester/trunk/main/test-utils.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+proc_killer() {
+    local PROC
+    local TIMEOUT
+    local counter
+    PROC="$1"
+    TIMEOUT=$2
+    counter=0
+    while [ $counter -lt $TIMEOUT ]; do
+        sleep 10
+        counter=$(( counter + 10 ))
+    done
+    kill -2 $PROC >/dev/null 2>& 1
+    sleep 10
+    kill -15 $PROC >/dev/null 2>& 1
+    sleep 10
+    kill -9 $PROC >/dev/null 2>& 1
+}

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);
+}