--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.asm.hsail/src/com/oracle/graal/asm/hsail/AbstractHSAILAssembler.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.asm.hsail;
+
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.asm.*;
+
+/**
+ * The platform-dependent base class for the HSAIL assembler.
+ */
+public abstract class AbstractHSAILAssembler extends AbstractAssembler {
+
+    public AbstractHSAILAssembler(TargetDescription target) {
+        super(target);
+    }
+
+    @Override
+    public final void bind(Label l) {
+        super.bind(l);
+        emitString0(nameOf(l) + ":\n");
+    }
+
+    @Override
+    public void align(int modulus) {
+        // Nothing to do
+    }
+
+    @Override
+    public void jmp(Label l) {
+        emitString("brn " + nameOf(l) + ";");
+    }
+
+    @Override
+    protected void patchJumpTarget(int branch, int jumpTarget) {
+        // Nothing to do
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.asm.hsail/src/com/oracle/graal/asm/hsail/HSAILAddress.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.asm.hsail;
+
+import com.oracle.graal.api.code.*;
+
+import com.oracle.graal.api.meta.*;
+
+/**
+ * Represents an address in target machine memory, specified via some combination of a base register
+ * and a displacement.
+ */
+public final class HSAILAddress extends AbstractAddress {
+
+    private final Register base;
+    private final long displacement;
+
+    /**
+     * Creates an {@link HSAILAddress} with given base register and no displacement.
+     * 
+     * 
+     * @param base the base register
+     */
+    public HSAILAddress(Register base) {
+        this(base, 0);
+    }
+
+    /**
+     * Creates an {@link HSAILAddress} with given base register and a displacement. This is the most
+     * general constructor.
+     * 
+     * @param base the base register
+     * @param displacement the displacement
+     */
+    public HSAILAddress(Register base, long displacement) {
+        this.base = base;
+        this.displacement = displacement;
+    }
+
+    /**
+     * @return Base register that defines the start of the address computation. If not present, is
+     *         denoted by {@link Value#ILLEGAL}.
+     */
+    public Register getBase() {
+        return base;
+    }
+
+    /**
+     * @return Optional additive displacement.
+     */
+    public long getDisplacement() {
+        return displacement;
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.asm.hsail/src/com/oracle/graal/asm/hsail/HSAILAssembler.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.asm.hsail;
+
+import com.oracle.graal.api.code.*;
+
+import static com.oracle.graal.api.code.ValueUtil.*;
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.hsail.*;
+import com.oracle.graal.graph.GraalInternalError;
+import com.amd.okra.OkraUtil;
+
+/**
+ * This class contains routines to emit HSAIL assembly code.
+ */
+public class HSAILAssembler extends AbstractHSAILAssembler {
+
+    /**
+     * Stack size in bytes (used to keep track of spilling).
+     */
+    private int maxDataTypeSize;
+
+    /**
+     * Maximum stack offset used by a store operation.
+     */
+    private long maxStackOffset = 0;
+
+    public long upperBoundStackSize() {
+        return maxStackOffset + maxDataTypeSize;
+    }
+
+    public HSAILAssembler(TargetDescription target) {
+        super(target);
+    }
+
+    @Override
+    public HSAILAddress makeAddress(Register base, int displacement) {
+        return new HSAILAddress(base, displacement);
+    }
+
+    @Override
+    public HSAILAddress getPlaceholder() {
+        return null;
+    }
+
+    public final void undefined(String str) {
+        emitString("undefined operation " + str);
+    }
+
+    public final void exit() {
+        emitString("ret;" + "");
+    }
+
+    /**
+     * An Object is only moved into a register when it is a class constant (which is not really a
+     * constant because it can be moved by GC). Because we can't patch the HSAIL once it is
+     * finalized, we handle changes due to GC movement by dereferencing a global reference that is
+     * created by JNI since these JNI global references do not move.
+     */
+    public final void mov(Register a, Object obj) {
+        if (obj instanceof Class) {
+            Class<?> clazz = (Class<?>) obj;
+            long refHandle = OkraUtil.getRefHandle(clazz);
+            String className = clazz.getName();
+            String regName = "$d" + a.encoding();
+            emitString("mov_b64 " + regName + ", 0x" + Long.toHexString(refHandle) + ";  // handle for " + className);
+            emitString("ld_global_u64 " + regName + ", [" + regName + "];");
+        } else {
+            throw GraalInternalError.shouldNotReachHere("mov from object not a class");
+        }
+
+    }
+
+    public final void emitMov(Value dst, Value src) {
+        if (isRegister(dst) && isConstant(src) && src.getKind().getStackKind() == Kind.Object) {
+            mov(asRegister(dst), (asConstant(src)).asObject());
+        } else {
+            String argtype = getArgType(dst).substring(1);
+            emitString("mov_b" + argtype + " " + mapRegOrConstToString(dst) + ", " + mapRegOrConstToString(src) + ";");
+        }
+    }
+
+    public final void emitLoad(Value dest, HSAILAddress addr) {
+        emitString("ld_global_" + getArgType(dest) + " " + HSAIL.mapRegister(dest) + ", " + mapAddress(addr) + ";");
+    }
+
+    public final void emitSpillLoad(Value dest, Value src) {
+        emitString("ld_spill_" + getArgType(dest) + " " + HSAIL.mapRegister(dest) + ", " + HSAIL.mapStackSlot(src) + ";");
+    }
+
+    public final void emitStore(Value src, HSAILAddress addr) {
+        emitString("st_global_" + getArgType(src) + " " + HSAIL.mapRegister(src) + ", " + mapAddress(addr) + ";");
+    }
+
+    public final void emitSpillStore(Value src, Value dest) {
+        int sizestored = getArgSize(src);
+        if (maxDataTypeSize < sizestored) {
+            maxDataTypeSize = sizestored;
+        }
+        int stackoffset = HSAIL.getStackOffset(dest);
+        if (maxStackOffset < stackoffset) {
+            maxStackOffset = stackoffset;
+        }
+        emitString("st_spill_" + getArgType(src) + " " + HSAIL.mapRegister(src) + ", " + HSAIL.mapStackSlot(dest) + ";");
+    }
+
+    public void cbr(String target1) {
+        emitString("cbr " + "$c0" + ", " + target1 + ";");
+    }
+
+    public int getArgSize(Value src) {
+        switch (src.getKind()) {
+            case Int:
+            case Float:
+                return 32;
+            case Double:
+            case Long:
+            case Object:
+                return 64;
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+        }
+    }
+
+    public static final String getArgType(Value src) {
+        String prefix = "";
+        switch (src.getKind()) {
+            case Float:
+                prefix = "f32";
+                break;
+            case Double:
+                prefix = "f64";
+                break;
+            case Int:
+                prefix = "s32";
+                break;
+            case Long:
+                prefix = "s64";
+                break;
+            case Object:
+                prefix = "u64";
+                break;
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+        }
+        return prefix;
+    }
+
+    public static final String getArgTypeForceUnsigned(Value src) {
+        switch (src.getKind()) {
+            case Int:
+                return "u32";
+            case Long:
+            case Object:
+                return "u64";
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+        }
+    }
+
+    public void emitCompare(Value src0, Value src1, String condition, boolean unordered, boolean isUnsignedCompare) {
+        String prefix = "cmp_" + condition + (unordered ? "u" : "") + "_b1_" + (isUnsignedCompare ? getArgTypeForceUnsigned(src1) : getArgType(src1));
+        emitString(prefix + " $c0, " + mapRegOrConstToString(src0) + ", " + mapRegOrConstToString(src1) + ";");
+    }
+
+    public void emitConvert(Value dest, Value src) {
+        String prefix = (getArgType(dest).equals("f32") && getArgType(src).equals("f64")) ? "cvt_near_" : "cvt_";
+        emitString(prefix + getArgType(dest) + "_" + getArgType(src) + " " + HSAIL.mapRegister(dest) + ", " + HSAIL.mapRegister(src) + ";");
+    }
+
+    public void emitArg1(String mnemonic, Value dest, Value src) {
+        emitString(mnemonic + "_" + getArgType(src) + " " + HSAIL.mapRegister(dest) + ", " + mapRegOrConstToString(src) + ";" + "");
+    }
+
+    public static String mapAddress(HSAILAddress addr) {
+        return "[$d" + addr.getBase().encoding() + " + " + addr.getDisplacement() + "]";
+    }
+
+    private static String mapRegOrConstToString(Value src) {
+        if (!isConstant(src)) {
+            return HSAIL.mapRegister(src);
+        } else {
+            Constant consrc = asConstant(src);
+            switch (src.getKind()) {
+                case Int:
+                    return Integer.toString(consrc.asInt());
+                case Float:
+                    return Float.toString(consrc.asFloat()) + "f";
+                case Double:
+                    return Double.toString(consrc.asDouble());
+                case Long:
+                    return Long.toString(consrc.asLong());
+                default:
+                    throw GraalInternalError.shouldNotReachHere("unknown type: " + src);
+            }
+        }
+
+    }
+
+    public final void emit(String mnemonic, Value dest, Value src0, Value src1) {
+        String prefix = getArgType(dest);
+        emit(mnemonic + "_" + prefix, dest, "", src0, src1);
+    }
+
+    private void emit(String instr, Value dest, String controlRegString, Value src0, Value src1) {
+        assert (!isConstant(dest));
+        emitString(String.format("%s %s, %s%s, %s;", instr, HSAIL.mapRegister(dest), controlRegString, mapRegOrConstToString(src0), mapRegOrConstToString(src1)));
+    }
+
+    public final void cmovCommon(Value dest, Value trueReg, Value falseReg, int width) {
+        String instr = (width == 32 ? "cmov_b32" : "cmov_b64");
+        emit(instr, dest, "$c0, ", trueReg, falseReg);
+    }
+
+}

--- a/graal/com.oracle.graal.asm.ptx/src/com/oracle/graal/asm/ptx/AbstractPTXAssembler.java	Tue Jul 09 11:19:53 2013 +0200
+++ b/graal/com.oracle.graal.asm.ptx/src/com/oracle/graal/asm/ptx/AbstractPTXAssembler.java	Tue Jul 09 11:21:06 2013 +0200
@@ -34,30 +34,25 @@
         super(target);
     }
 
-    public static final String UNBOUND_TARGET = "L" + Integer.MAX_VALUE;
-
     @Override
     public final void bind(Label l) {
         super.bind(l);
-        emitString0("L" + l.toString() + ":\n");
+        emitString0(nameOf(l) + ":\n");
     }
 
     @Override
     public void align(int modulus) {
-        // TODO Auto-generated method stub
+        // Nothing to do
     }
 
     @Override
     public void jmp(Label l) {
-        // TODO Auto-generated method stub
+        // Nothing to do
     }
 
     @Override
     protected void patchJumpTarget(int branch, int jumpTarget) {
-        final int spaces = UNBOUND_TARGET.length();
-        String targetString = String.format("L%-" + spaces + "s", jumpTarget + ";");
-        int offset = "\tbra ".length();  // XXX we need a better way to figure this out
-        codeBuffer.emitString(targetString, branch + offset);
+        // Nothing to do. All branches already point to the right label.
     }
 
 }

--- a/graal/com.oracle.graal.asm/src/com/oracle/graal/asm/AbstractAssembler.java	Tue Jul 09 11:19:53 2013 +0200
+++ b/graal/com.oracle.graal.asm/src/com/oracle/graal/asm/AbstractAssembler.java	Tue Jul 09 11:21:06 2013 +0200
@@ -23,6 +23,7 @@
 package com.oracle.graal.asm;
 
 import java.nio.*;
+import java.util.*;
 
 import com.oracle.graal.api.code.*;
 
@@ -56,6 +57,34 @@
 
     protected abstract void patchJumpTarget(int branch, int jumpTarget);
 
+    private Map<Label, String> nameMap;
+
+    /**
+     * Creates a name for a label.
+     * 
+     * @param l the label for which a name is being created
+     * @param id a label identifier that is unique with the scope of this assembler
+     */
+    protected String createLabelName(Label l, int id) {
+        return "@L" + id;
+    }
+
+    /**
+     * Gets a name for a label, creating it if it does not yet exist. By default, the returned name
+     * is only unique with the scope of this assembler.
+     */
+    public String nameOf(Label l) {
+        if (nameMap == null) {
+            nameMap = new HashMap<>();
+        }
+        String name = nameMap.get(l);
+        if (name == null) {
+            name = createLabelName(l, nameMap.size());
+            nameMap.put(l, name);
+        }
+        return name;
+    }
+
     protected final void emitByte(int x) {
         codeBuffer.emitByte(x);
     }

--- a/graal/com.oracle.graal.asm/src/com/oracle/graal/asm/Label.java	Tue Jul 09 11:19:53 2013 +0200
+++ b/graal/com.oracle.graal.asm/src/com/oracle/graal/asm/Label.java	Tue Jul 09 11:21:06 2013 +0200
@@ -22,7 +22,7 @@
  */
 package com.oracle.graal.asm;
 
-import java.util.ArrayList;
+import java.util.*;
 
 /**
  * This class represents a label within assembly code.
@@ -66,7 +66,7 @@
     }
 
     public void addPatchAt(int branchLocation) {
-        assert !isBound() : "Label is already bound";
+        assert !isBound() : "Label is already bound " + this + " " + branchLocation + " at position " + position;
         patchPositions.add(branchLocation);
     }
 

--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Tue Jul 09 11:19:53 2013 +0200
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Tue Jul 09 11:21:06 2013 +0200
@@ -241,6 +241,13 @@
     }
 
     @Override
+    protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) {
+        AllocatableValue targetAddress = AMD64.rax.asValue();
+        emitMove(targetAddress, operand(callTarget.computedAddress()));
+        append(new AMD64Call.IndirectCallOp(callTarget.target(), result, parameters, temps, targetAddress, callState));
+    }
+
+    @Override
     public void emitOverflowCheckBranch(LabelRef destination, boolean negated) {
         append(new BranchOp(negated ? ConditionFlag.NoOverflow : ConditionFlag.Overflow, destination));
     }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test.infra/src/com/oracle/graal/compiler/hsail/test/infra/GraalKernelTester.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test.infra;
+
+/**
+ * This class extends KernelTester and provides a base class
+ * for which the HSAIL code comes from the Graal compiler.
+ */
+import com.oracle.graal.compiler.hsail.HSAILCompilationResult;
+import java.lang.reflect.Method;
+import java.io.*;
+
+public abstract class GraalKernelTester extends KernelTester {
+
+    HSAILCompilationResult hsailCompResult;
+    private boolean showHsailSource = false;
+    private boolean saveInFile = false;
+
+    @Override
+    public String getCompiledHSAILSource(Method testMethod) {
+        if (hsailCompResult == null) {
+            hsailCompResult = HSAILCompilationResult.getHSAILCompilationResult(testMethod);
+        }
+        String hsailSource = hsailCompResult.getHSAILCode();
+        if (showHsailSource) {
+            logger.severe(hsailSource);
+        }
+        if (saveInFile) {
+            try {
+                File fout = File.createTempFile("tmp", ".hsail");
+                logger.fine("creating " + fout.getCanonicalPath());
+                FileWriter fw = new FileWriter(fout);
+                BufferedWriter bw = new BufferedWriter(fw);
+                bw.write(hsailSource);
+                bw.close();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return hsailSource;
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test.infra/src/com/oracle/graal/compiler/hsail/test/infra/KernelTester.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,829 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.compiler.hsail.test.infra;
+
+import static org.junit.Assert.*;
+import static org.junit.Assume.*;
+
+import java.io.*;
+import java.lang.annotation.*;
+import java.lang.reflect.*;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.atomic.*;
+import java.util.logging.*;
+
+import com.amd.okra.*;
+
+/**
+ * Abstract class on which the HSAIL unit tests are built. Executes a method or lambda on both the
+ * Java side and the Okra side and compares the results for fields that are annotated with
+ * {@link KernelTester.Result}.
+ */
+public abstract class KernelTester {
+
+    /**
+     * Denotes a field whose value is to be compared as part of computing the result of a test.
+     */
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.FIELD)
+    public @interface Result {
+    }
+
+    // Using these in case we want to compile with Java 7.
+    public interface MyIntConsumer {
+
+        void accept(int value);
+    }
+
+    public interface MyObjConsumer {
+
+        void accept(Object obj);
+    }
+
+    public enum DispatchMode {
+        SEQ, JTP, OKRA
+    }
+
+    public enum HsailMode {
+        COMPILED, INJECT_HSAIL, INJECT_OCL
+    }
+
+    private DispatchMode dispatchMode;
+    // Where the hsail comes from.
+    private HsailMode hsailMode;
+    private Method testMethod;
+    // What type of okra dispatch to use when client calls.
+    private boolean useLambdaMethod;
+    private Class<?>[] testMethodParams = null;
+    private int id = nextId.incrementAndGet();
+    static AtomicInteger nextId = new AtomicInteger(0);
+    public static Logger logger;
+    private OkraContext okraContext;
+    private OkraKernel okraKernel;
+    private static final String propPkgName = KernelTester.class.getPackage().getName();
+    private static Level logLevel;
+    private static ConsoleHandler consoleHandler;
+
+    static {
+        logger = Logger.getLogger(propPkgName);
+        logLevel = Level.parse(System.getProperty("kerneltester.logLevel", "SEVERE"));
+
+        // This block configure the logger with handler and formatter.
+        consoleHandler = new ConsoleHandler();
+        logger.addHandler(consoleHandler);
+        logger.setUseParentHandlers(false);
+        SimpleFormatter formatter = new SimpleFormatter() {
+
+            @SuppressWarnings("sync-override")
+            @Override
+            public String format(LogRecord record) {
+                return (record.getMessage() + "\n");
+            }
+        };
+        consoleHandler.setFormatter(formatter);
+        setLogLevel(logLevel);
+    }
+
+    private static boolean gaveNoOkraWarning = false;
+    private boolean onSimulator;
+    private boolean okraLibExists;
+
+    public boolean runningOnSimulator() {
+        return onSimulator;
+    }
+
+    public KernelTester() {
+        okraLibExists = OkraUtil.okraLibExists();
+        dispatchMode = DispatchMode.SEQ;
+        hsailMode = HsailMode.COMPILED;
+        useLambdaMethod = false;
+    }
+
+    public abstract void runTest();
+
+    // Default comparison is to compare all things marked @Result.
+    public boolean compareResults(KernelTester base) {
+        Class<?> clazz = this.getClass();
+        while (clazz != null && clazz != KernelTester.class) {
+            for (Field f : clazz.getDeclaredFields()) {
+                if (!Modifier.isStatic(f.getModifiers())) {
+                    Result annos = f.getAnnotation(Result.class);
+                    if (annos != null) {
+                        logger.fine("@Result field = " + f);
+                        Object myResult = getFieldFromObject(f, this);
+                        Object otherResult = getFieldFromObject(f, base);
+                        boolean same = compareObjects(myResult, otherResult);
+                        logger.fine("comparing " + myResult + ", " + otherResult + ", match=" + same);
+                        if (!same) {
+                            logger.severe("mismatch comparing " + f + ", " + myResult + " vs. " + otherResult);
+                            logSevere("FAILED!!! " + this.getClass());
+                            return false;
+                        }
+                    }
+                }
+            }
+            clazz = clazz.getSuperclass();
+        }
+        logInfo("PASSED: " + this.getClass());
+        return true;
+    }
+
+    private boolean compareObjects(Object first, Object second) {
+        Class<?> clazz = first.getClass();
+        if (clazz != second.getClass()) {
+            return false;
+        }
+        if (!clazz.isArray()) {
+            // Non arrays.
+            if (clazz.equals(float.class) || clazz.equals(double.class)) {
+                return isEqualsFP((double) first, (double) second);
+            } else {
+                return first.equals(second);
+            }
+        } else {
+            // Handle the case where Objects are arrays.
+            ArrayComparer comparer;
+            if (clazz.equals(float[].class) || clazz.equals(double[].class)) {
+                comparer = new FPArrayComparer();
+            } else if (clazz.equals(long[].class) || clazz.equals(int[].class) || clazz.equals(byte[].class)) {
+                comparer = new IntArrayComparer();
+            } else if (clazz.equals(boolean[].class)) {
+                comparer = new BooleanArrayComparer();
+            } else {
+                comparer = new ObjArrayComparer();
+            }
+            return comparer.compareArrays(first, second);
+        }
+    }
+
+    static final int MISMATCHLIMIT = 10;
+    static final int ELEMENTDISPLAYLIMIT = 20;
+
+    public int getMisMatchLimit() {
+        return MISMATCHLIMIT;
+    }
+
+    public int getElementDisplayLimit() {
+        return ELEMENTDISPLAYLIMIT;
+    }
+
+    abstract class ArrayComparer {
+
+        abstract Object getElement(Object ary, int index);
+
+        // Equality test, can be overridden
+        boolean isEquals(Object firstElement, Object secondElement) {
+            return firstElement.equals(secondElement);
+        }
+
+        boolean compareArrays(Object first, Object second) {
+            int len = Array.getLength(first);
+            if (len != Array.getLength(second)) {
+                return false;
+            }
+            // If info logLevel, build string of first few elements from first array.
+            if (logLevel.intValue() <= Level.INFO.intValue()) {
+                StringBuilder sb = new StringBuilder();
+                for (int i = 0; i < Math.min(len, getElementDisplayLimit()); i++) {
+                    sb.append(getElement(first, i));
+                    sb.append(", ");
+                }
+                logger.info(sb.toString());
+            }
+            boolean success = true;
+            int mismatches = 0;
+            for (int i = 0; i < len; i++) {
+                Object firstElement = getElement(first, i);
+                Object secondElement = getElement(second, i);
+                if (!isEquals(firstElement, secondElement)) {
+                    logSevere("mismatch at index " + i + ", expected " + secondElement + ", saw " + firstElement);
+                    success = false;
+                    mismatches++;
+                    if (mismatches >= getMisMatchLimit()) {
+                        logSevere("...Truncated");
+                        break;
+                    }
+                }
+            }
+            return success;
+        }
+    }
+
+    class FPArrayComparer extends ArrayComparer {
+
+        @Override
+        Object getElement(Object ary, int index) {
+            return Array.getDouble(ary, index);
+        }
+
+        @Override
+        boolean isEquals(Object firstElement, Object secondElement) {
+            return isEqualsFP((double) firstElement, (double) secondElement);
+        }
+    }
+
+    class IntArrayComparer extends ArrayComparer {
+
+        @Override
+        Object getElement(Object ary, int index) {
+            return Array.getLong(ary, index);
+        }
+    }
+
+    class BooleanArrayComparer extends ArrayComparer {
+
+        @Override
+        Object getElement(Object ary, int index) {
+            return Array.getBoolean(ary, index);
+        }
+    }
+
+    class ObjArrayComparer extends ArrayComparer {
+
+        @Override
+        Object getElement(Object ary, int index) {
+            return Array.get(ary, index);
+        }
+    }
+
+    /**
+     * This isEqualsFP method allows subclass to override what FP equality means for this particular
+     * unit test.
+     */
+    public boolean isEqualsFP(double first, double second) {
+        return first == second;
+    }
+
+    public void setDispatchMode(DispatchMode dispatchMode) {
+        this.dispatchMode = dispatchMode;
+    }
+
+    public void setHsailMode(HsailMode hsailMode) {
+        this.hsailMode = hsailMode;
+    }
+
+    /**
+     * Return a clone of this instance unless overridden, we just call the null constructor.
+     */
+    public KernelTester newInstance() {
+        try {
+            return this.getClass().getConstructor((Class<?>[]) null).newInstance();
+        } catch (Throwable t) {
+            fail("Unexpected exception " + t);
+            return null;
+        }
+    }
+
+    public Method getMethodFromMethodName(String methName, Class<?> clazz) {
+        Class<?> clazz2 = clazz;
+        while (clazz2 != null) {
+            for (Method m : clazz2.getDeclaredMethods()) {
+                logger.fine(" in " + clazz2 + ", trying to match " + m);
+                if (m.getName().equals(methName)) {
+                    testMethodParams = m.getParameterTypes();
+                    if (logLevel.intValue() <= Level.FINE.intValue()) {
+                        logger.fine(" in " + clazz2 + ", matched " + m);
+                        logger.fine("parameter types are...");
+                        int paramNum = 0;
+                        for (Class<?> pclazz : testMethodParams) {
+                            logger.fine(paramNum++ + ") " + pclazz.toString());
+                        }
+                    }
+                    return m;
+                }
+            }
+            // Didn't find it in current clazz, try superclass.
+            clazz2 = clazz2.getSuperclass();
+        }
+        // If we got this far, no match.
+        return null;
+    }
+
+    private void setTestMethod(String methName, Class<?> inClazz) {
+        testMethod = getMethodFromMethodName(methName, inClazz);
+        if (testMethod == null) {
+            fail("cannot find method " + methName + " in class " + inClazz);
+        } else {
+            // Print info but only for first such class.
+            if (id == 1) {
+                logger.fine("testMethod to be compiled is \n   " + testMethod);
+            }
+        }
+    }
+
+    // Default is method name "run", but could be overridden.
+    private final String defaultMethodName = "run";
+
+    public String getTestMethodName() {
+        return defaultMethodName;
+    }
+
+    /**
+     * The dispatchMethodKernel dispatches a non-lambda method. All the parameters of the compiled
+     * method are supplied as parameters to this call.
+     */
+    public void dispatchMethodKernel(int range, Object... args) {
+        if (testMethod == null) {
+            setTestMethod(getTestMethodName(), this.getClass());
+        }
+        if (dispatchMode == DispatchMode.SEQ) {
+            dispatchMethodKernelSeq(range, args);
+        } else if (dispatchMode == DispatchMode.OKRA) {
+            dispatchMethodKernelOkra(range, args);
+        }
+    }
+
+    /**
+     * This dispatchLambdaMethodKernel dispatches the lambda version of a kernel where the "kernel"
+     * is for the lambda method itself (like lambda$0).
+     */
+    public void dispatchLambdaMethodKernel(int range, MyIntConsumer consumer) {
+        if (testMethod == null) {
+            setTestMethod(findLambdaMethodName(), this.getClass());
+        }
+        if (dispatchMode == DispatchMode.SEQ) {
+            dispatchLambdaKernelSeq(range, consumer);
+        } else if (dispatchMode == DispatchMode.OKRA) {
+            dispatchLambdaMethodKernelOkra(range, consumer);
+        }
+    }
+
+    public void dispatchLambdaMethodKernel(Object[] ary, MyObjConsumer consumer) {
+        if (testMethod == null) {
+            setTestMethod(findLambdaMethodName(), this.getClass());
+        }
+        if (dispatchMode == DispatchMode.SEQ) {
+            dispatchLambdaKernelSeq(ary, consumer);
+        } else if (dispatchMode == DispatchMode.OKRA) {
+            dispatchLambdaMethodKernelOkra(ary, consumer);
+        }
+    }
+
+    /**
+     * The dispatchLambdaKernel dispatches the lambda version of a kernel where the "kernel" is for
+     * the xxx$$Lambda.accept method in the wrapper for the lambda. Note that the useLambdaMethod
+     * boolean provides a way of actually invoking dispatchLambdaMethodKernel from this API.
+     */
+    public void dispatchLambdaKernel(int range, MyIntConsumer consumer) {
+        if (useLambdaMethod) {
+            dispatchLambdaMethodKernel(range, consumer);
+            return;
+        }
+        if (testMethod == null) {
+            setTestMethod("accept", consumer.getClass());
+        }
+        if (dispatchMode == DispatchMode.SEQ) {
+            dispatchLambdaKernelSeq(range, consumer);
+        } else if (dispatchMode == DispatchMode.OKRA) {
+            dispatchLambdaKernelOkra(range, consumer);
+        }
+    }
+
+    public void dispatchLambdaKernel(Object[] ary, MyObjConsumer consumer) {
+        if (useLambdaMethod) {
+            dispatchLambdaMethodKernel(ary, consumer);
+            return;
+        }
+        if (testMethod == null) {
+            setTestMethod("accept", consumer.getClass());
+        }
+        if (dispatchMode == DispatchMode.SEQ) {
+            dispatchLambdaKernelSeq(ary, consumer);
+        } else if (dispatchMode == DispatchMode.OKRA) {
+            dispatchLambdaKernelOkra(ary, consumer);
+        }
+    }
+
+    private ArrayList<String> getLambdaMethodNames() {
+        Class<?> clazz = this.getClass();
+        ArrayList<String> lambdaNames = new ArrayList<>();
+        while (clazz != null && (lambdaNames.size() == 0)) {
+            for (Method m : clazz.getDeclaredMethods()) {
+                logger.fine(" in " + clazz + ", trying to match " + m);
+                if (m.getName().startsWith("lambda$")) {
+                    lambdaNames.add(m.getName());
+                }
+            }
+            // Didn't find it in current clazz, try superclass.
+            clazz = clazz.getSuperclass();
+        }
+        return lambdaNames;
+    }
+
+    /**
+     * findLambdaMethodName finds a name in the class starting with lambda$. If we find more than
+     * one, throw an error, and tell user to override explicitly
+     */
+    private String findLambdaMethodName() {
+        // If user overrode getTestMethodName, use that name.
+        if (!getTestMethodName().equals(defaultMethodName)) {
+            return getTestMethodName();
+        } else {
+            ArrayList<String> lambdaNames = getLambdaMethodNames();
+            switch (lambdaNames.size()) {
+                case 1:
+                    return lambdaNames.get(0);
+                case 0:
+                    fail("No lambda method found in " + this.getClass());
+                    return null;
+                default:
+                    // More than one lambda.
+                    String msg = "Multiple lambda methods found in " + this.getClass() + "\nYou should override getTestMethodName with one of the following\n";
+                    for (String name : lambdaNames) {
+                        msg = msg + name + "\n";
+                    }
+                    fail(msg);
+                    return null;
+            }
+        }
+    }
+
+    /**
+     * The getCompiledHSAILSource returns the string of HSAIL code for the compiled method. By
+     * default, throws an error. In graal for instance, this would be overridden in
+     * GraalKernelTester.
+     */
+    public String getCompiledHSAILSource(Method testMethod1) {
+        fail("no compiler connected so unable to compile " + testMethod1 + "\nYou could try injecting HSAIL or OpenCL");
+        return null;
+    }
+
+    public String getHSAILSource(Method testMethod1) {
+        switch (hsailMode) {
+            case COMPILED:
+                return getCompiledHSAILSource(testMethod1);
+            case INJECT_HSAIL:
+                return getHsailFromClassnameHsailFile();
+            case INJECT_OCL:
+                return getHsailFromClassnameOclFile();
+            default:
+                fail("unknown hsailMode = " + hsailMode);
+                return null;
+        }
+    }
+
+    /**
+     * The getHSAILKernelName returns the name of the hsail kernel. By default we use 'run'. unless
+     * coming from opencl injection. Could be overridden by the junit test.
+     */
+    public String getHSAILKernelName() {
+        return (hsailMode != HsailMode.INJECT_OCL ? "&run" : "&__OpenCL_run_kernel");
+    }
+
+    private void createOkraKernel() {
+        // Call routines in the derived class to get the hsail code and kernel name.
+        String hsailSource = getHSAILSource(testMethod);
+        if (!okraLibExists) {
+            if (!gaveNoOkraWarning) {
+                logger.fine("No Okra library detected, skipping all KernelTester tests in " + this.getClass().getPackage().getName());
+                gaveNoOkraWarning = true;
+            }
+        }
+        // Ignore any kerneltester test if okra does not exist.
+        assumeTrue(okraLibExists);
+        // Control which okra instances can run the tests.
+        onSimulator = OkraContext.isSimulator();
+        okraContext = new OkraContext();
+        if (!okraContext.isValid()) {
+            fail("...unable to create context");
+        }
+        // Control verbosity in okra from our logLevel.
+        if (logLevel.intValue() <= Level.INFO.intValue()) {
+            okraContext.setVerbose(true);
+        }
+        okraKernel = new OkraKernel(okraContext, hsailSource, getHSAILKernelName());
+        if (!okraKernel.isValid()) {
+            fail("...unable to create kernel");
+        }
+    }
+
+    private void dispatchKernelOkra(int range, Object... args) {
+        if (okraKernel == null) {
+            createOkraKernel();
+        }
+        if (logLevel.intValue() <= Level.FINE.intValue()) {
+            logger.fine("Arguments passed to okra...");
+            for (Object arg : args) {
+                logger.fine("  " + arg);
+            }
+        }
+        okraKernel.setLaunchAttributes(range);
+        okraKernel.dispatchWithArgs(args);
+    }
+
+    private void dispatchMethodKernelSeq(int range, Object... args) {
+        Object[] invokeArgs = new Object[args.length + 1];
+        // Need space on the end for the gid parameter.
+        System.arraycopy(args, 0, invokeArgs, 0, args.length);
+        int gidArgIndex = invokeArgs.length - 1;
+        if (logLevel.intValue() <= Level.FINE.intValue()) {
+            for (Object arg : args) {
+                logger.fine(arg.toString());
+            }
+        }
+        for (int rangeIndex = 0; rangeIndex < range; rangeIndex++) {
+            invokeArgs[gidArgIndex] = rangeIndex;
+            try {
+                testMethod.invoke(this, invokeArgs);
+            } catch (IllegalAccessException e) {
+                fail("could not invoke " + testMethod + ", make sure it is public");
+            } catch (IllegalArgumentException e) {
+                fail("wrong arguments invoking " + testMethod + ", check number and type of args passed to dispatchMethodKernel");
+            } catch (InvocationTargetException e) {
+                Throwable cause = e.getCause();
+                /**
+                 * We will ignore ArrayIndexOutOfBoundsException because the graal okra target
+                 * doesn't really handle it yet (basically returns early if it sees one).
+                 */
+                if (cause instanceof ArrayIndexOutOfBoundsException) {
+                    logger.severe("ignoring ArrayIndexOutOfBoundsException for index " + rangeIndex);
+                } else {
+                    // Other exceptions.
+                    String errstr = testMethod + " threw an exception on gid=" + rangeIndex + ", exception was " + cause;
+                    fail(errstr);
+                }
+            } catch (Exception e) {
+                fail("Unknown exception " + e + " invoking " + testMethod);
+            }
+        }
+    }
+
+    private void dispatchMethodKernelOkra(int range, Object... args) {
+        Object[] fixedArgs = fixArgTypes(args);
+        if (Modifier.isStatic(testMethod.getModifiers())) {
+            dispatchKernelOkra(range, fixedArgs);
+        } else {
+            // If it is a non-static method we have to push "this" as the first argument.
+            Object[] newFixedArgs = new Object[fixedArgs.length + 1];
+            System.arraycopy(fixedArgs, 0, newFixedArgs, 1, fixedArgs.length);
+            newFixedArgs[0] = this;
+            dispatchKernelOkra(range, newFixedArgs);
+        }
+    }
+
+    /**
+     * For primitive arg parameters, make sure arg types are cast to whatever the testMethod
+     * signature says they should be.
+     */
+    private Object[] fixArgTypes(Object[] args) {
+        Object[] fixedArgs = new Object[args.length];
+        for (int i = 0; i < args.length; i++) {
+            Class<?> paramClass = testMethodParams[i];
+            if (paramClass.equals(Float.class) || paramClass.equals(float.class)) {
+                fixedArgs[i] = ((Number) args[i]).floatValue();
+            } else if (paramClass.equals(Integer.class) || paramClass.equals(int.class)) {
+                fixedArgs[i] = ((Number) args[i]).intValue();
+            } else if (paramClass.equals(Long.class) || paramClass.equals(long.class)) {
+                fixedArgs[i] = ((Number) args[i]).longValue();
+            } else if (paramClass.equals(Double.class) || paramClass.equals(double.class)) {
+                fixedArgs[i] = ((Number) args[i]).doubleValue();
+            } else if (paramClass.equals(Byte.class) || paramClass.equals(byte.class)) {
+                fixedArgs[i] = ((Number) args[i]).byteValue();
+            } else if (paramClass.equals(Boolean.class) || paramClass.equals(boolean.class)) {
+                fixedArgs[i] = (boolean) args[i];
+            } else {
+                // All others just move unchanged.
+                fixedArgs[i] = args[i];
+            }
+        }
+        return fixedArgs;
+    }
+
+    /**
+     * Dispatching a lambda on the java side is simple.
+     */
+    @SuppressWarnings("static-method")
+    private void dispatchLambdaKernelSeq(int range, MyIntConsumer consumer) {
+        for (int i = 0; i < range; i++) {
+            consumer.accept(i);
+        }
+    }
+
+    @SuppressWarnings("static-method")
+    private void dispatchLambdaKernelSeq(Object[] ary, MyObjConsumer consumer) {
+        for (Object obj : ary) {
+            consumer.accept(obj);
+        }
+    }
+
+    /**
+     * The dispatchLambdaMethodKernelOkra dispatches in the case where the hsail kernel implements
+     * the lambda method itself as opposed to the wrapper that calls the lambda method. From the
+     * consumer object, we need to find the fields and pass them to the kernel.
+     */
+    private void dispatchLambdaMethodKernelOkra(int range, MyIntConsumer consumer) {
+        logger.info("To determine parameters to pass to hsail kernel, we will examine   " + consumer.getClass());
+        Field[] fields = consumer.getClass().getDeclaredFields();
+        Object[] args = new Object[fields.length];
+        int argIndex = 0;
+        for (Field f : fields) {
+            logger.info("... " + f);
+            args[argIndex++] = getFieldFromObject(f, consumer);
+        }
+        dispatchKernelOkra(range, args);
+    }
+
+    private void dispatchLambdaMethodKernelOkra(Object[] ary, MyObjConsumer consumer) {
+        logger.info("To determine parameters to pass to hsail kernel, we will examine   " + consumer.getClass());
+        Field[] fields = consumer.getClass().getDeclaredFields();
+        Object[] args = new Object[fields.length];
+        int argIndex = 0;
+        for (Field f : fields) {
+            logger.info("... " + f);
+            args[argIndex++] = getFieldFromObject(f, consumer);
+        }
+        dispatchKernelOkra(ary.length, args);
+    }
+
+    /**
+     * The dispatchLambdaKernelOkra dispatches in the case where the hsail kernel where the hsail
+     * kernel implements the accept method of the wrapper that calls the lambda method as opposed to
+     * the actual lambda method itself.
+     */
+    private void dispatchLambdaKernelOkra(int range, MyIntConsumer consumer) {
+        // The "wrapper" method always has only one arg consisting of the consumer.
+        Object[] args = new Object[1];
+        args[0] = consumer;
+        dispatchKernelOkra(range, args);
+    }
+
+    private void dispatchLambdaKernelOkra(Object[] ary, MyObjConsumer consumer) {
+        // The "wrapper" method always has only one arg consisting of the consumer.
+        Object[] args = new Object[1];
+        args[0] = consumer;
+        dispatchKernelOkra(ary.length, args);
+    }
+
+    private void disposeKernelOkra() {
+        if (okraContext != null) {
+            okraContext.dispose();
+        }
+    }
+
+    private void compareOkraToSeq(HsailMode hsailMode1) {
+        compareOkraToSeq(hsailMode1, false);
+    }
+
+    /**
+     * Runs this instance on OKRA, and as SEQ and compares the output of the two executions.
+     */
+    private void compareOkraToSeq(HsailMode hsailMode1, boolean useLambda) {
+        // Create and run sequential instance.
+        KernelTester testerSeq = newInstance();
+        testerSeq.setDispatchMode(DispatchMode.SEQ);
+        testerSeq.runTest();
+        // Now do this object.
+        this.setHsailMode(hsailMode1);
+        this.setDispatchMode(DispatchMode.OKRA);
+        this.useLambdaMethod = useLambda;
+        this.runTest();
+        this.disposeKernelOkra();
+        assertTrue("failed comparison to SEQ", compareResults(testerSeq));
+    }
+
+    public void testGeneratedHsail() {
+        compareOkraToSeq(HsailMode.COMPILED);
+    }
+
+    public void testGeneratedHsailUsingLambdaMethod() {
+        compareOkraToSeq(HsailMode.COMPILED, true);
+    }
+
+    public void testInjectedHsail() {
+        newInstance().compareOkraToSeq(HsailMode.INJECT_HSAIL);
+    }
+
+    public void testInjectedOpencl() {
+        newInstance().compareOkraToSeq(HsailMode.INJECT_OCL);
+    }
+
+    private static Object getFieldFromObject(Field f, Object fromObj) {
+        try {
+            f.setAccessible(true);
+            Type type = f.getType();
+            logger.info("type = " + type);
+            if (type == double.class) {
+                return f.getDouble(fromObj);
+            } else if (type == float.class) {
+                return f.getFloat(fromObj);
+            } else if (type == long.class) {
+                return f.getLong(fromObj);
+            } else if (type == int.class) {
+                return f.getInt(fromObj);
+            } else if (type == byte.class) {
+                return f.getByte(fromObj);
+            } else if (type == boolean.class) {
+                return f.getBoolean(fromObj);
+            } else {
+                return f.get(fromObj);
+            }
+        } catch (Exception e) {
+            fail("unable to get field " + f + " from " + fromObj);
+            return null;
+        }
+    }
+
+    public static void checkFileExists(String fileName) {
+        assertTrue(fileName + " does not exist", fileExists(fileName));
+    }
+
+    public static boolean fileExists(String fileName) {
+        return new File(fileName).exists();
+    }
+
+    public static String getFileAsString(String sourceFileName) {
+        String source = null;
+        try {
+            checkFileExists(sourceFileName);
+            source = new String(Files.readAllBytes(FileSystems.getDefault().getPath(sourceFileName)));
+        } catch (IOException e) {
+            fail("could not open file " + sourceFileName);
+            return null;
+        }
+        return source;
+    }
+
+    public static String getHsailFromFile(String sourceFileName) {
+        logger.severe("... getting hsail from file " + sourceFileName);
+        return getFileAsString(sourceFileName);
+    }
+
+    private static void executeCmd(String... cmd) {
+        logger.info("spawning" + Arrays.toString(cmd));
+        try {
+            ProcessBuilder pb = new ProcessBuilder(cmd);
+            Process p = pb.start();
+            if (logLevel.intValue() <= Level.INFO.intValue()) {
+                InputStream in = p.getInputStream();
+                BufferedInputStream buf = new BufferedInputStream(in);
+                InputStreamReader inread = new InputStreamReader(buf);
+                BufferedReader bufferedreader = new BufferedReader(inread);
+                String line;
+                while ((line = bufferedreader.readLine()) != null) {
+                    logger.info(line);
+                }
+            }
+            p.waitFor();
+        } catch (Exception e) {
+            fail("could not execute <" + Arrays.toString(cmd) + ">");
+        }
+    }
+
+    public static String getHsailFromOpenCLFile(String openclFileName) {
+        String openclHsailFile = "opencl_out.hsail";
+        String tmpTahitiFile = "_temp_0_Tahiti.txt";
+        checkFileExists(openclFileName);
+        logger.severe("...converting " + openclFileName + " to HSAIL...");
+        executeCmd("aoc2", "-m64", "-I./", "-march=hsail", openclFileName);
+        if (fileExists(tmpTahitiFile)) {
+            return getFileAsString(tmpTahitiFile);
+        } else {
+            executeCmd("HSAILasm", "-disassemble", "-o", openclHsailFile, openclFileName.replace(".cl", ".bin"));
+            checkFileExists(openclHsailFile);
+            return getFileAsString(openclHsailFile);
+        }
+    }
+
+    public String getHsailFromClassnameHsailFile() {
+        return (getHsailFromFile(this.getClass().getSimpleName() + ".hsail"));
+    }
+
+    public String getHsailFromClassnameOclFile() {
+        return (getHsailFromOpenCLFile(this.getClass().getSimpleName() + ".cl"));
+    }
+
+    public static void logInfo(String msg) {
+        logger.info(msg);
+    }
+
+    public static void logSevere(String msg) {
+        logger.severe(msg);
+    }
+
+    public static void setLogLevel(Level level) {
+        logLevel = level;
+        logger.setLevel(level);
+        consoleHandler.setLevel(level);
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/BasicHSAILTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,363 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.*;
+
+import com.oracle.graal.compiler.test.GraalCompilerTest;
+import com.oracle.graal.compiler.hsail.HSAILCompilationResult;
+import com.oracle.graal.nodes.StructuredGraph;
+
+/**
+ * Test class for small Java methods compiled to HSAIL kernels.
+ */
+public class BasicHSAILTest extends GraalCompilerTest {
+
+    public void testAdd() {
+        test("testAddSnippet");
+    }
+
+    public static int testAddSnippet(int a) {
+        return a * a;
+    }
+
+    public void testArrayConstantIndex() {
+        test("testArrayReturnFirstElement");
+    }
+
+    public void testArrayVariableIndex() {
+        test("testArrayReturnIthElement");
+    }
+
+    public void testArrayMultiplyConstant() {
+        test("testArrayMultiplyZero");
+    }
+
+    public void testArrayMultiplyVar() {
+        test("testArrayMultiplyGid");
+    }
+
+    public void testArrayMisc() {
+        test("testArrayLocalVariable");
+    }
+
+    public void testArrayLoopVar() {
+        test("testArrayMultiplyGidLoop");
+    }
+
+    void setupPalette(int[] in) {
+        for (int i = 0; i < in.length; i++) {
+            in[i] = i;
+        }
+    }
+
+    public void testNBody() {
+        test("nBodySpill");
+    }
+
+    public void testArrayMandel() {
+        final int width = 768;
+        final int height = width;
+        int loopiterations = 1;
+        int counter = 0;
+        final int range = width * height;
+        int[] rgb = new int[range];
+        int[] palette = new int[range];
+        setupPalette(palette);
+        while (counter < loopiterations) {
+            for (int gid = 0; gid < range; gid++) {
+                testMandelSimple(rgb, palette, -1.0f, 0.0f, 3f, gid);
+            }
+            counter++;
+        }
+        test("testMandelSimple");
+    }
+
+    public void testDanglingElse() {
+        test("danglingElse");
+    }
+
+    public void testIntSquaresTernary() {
+        test("intSquaresTernary");
+    }
+
+    public void testDanglingElse2() {
+        test("danglingElse2");
+    }
+
+    public void testDanglingElse3() {
+        test("danglingElse3");
+    }
+
+    public void testSimpleIf() {
+        test("simpleIf");
+    }
+
+    public void testParams11() {
+        test("testParams1");
+    }
+
+    public void testParams21() {
+        test("testParams2");
+    }
+
+    public void testParams31() {
+        test("testParams3");
+    }
+
+    public void testAssignment1() {
+        test("testAssignment");
+    }
+
+    public void testArithmetic1() {
+        test("testArithmetic");
+    }
+
+    public void testSimpleWhile1() {
+        test("testSimpleWhile");
+    }
+
+    public void testComplexWhile1() {
+        test("testComplexWhile");
+    }
+
+    public void testSquaresThree() {
+        test("testMulThreeArrays");
+    }
+
+    @Test
+    public void testCondMoves() {
+        test("testMinI");
+        test("testMinF");
+    }
+
+    public int testMinI(int a, int b) {
+        return (a < b ? 1 : 2);
+    }
+
+    public float testMinF(int a, int b) {
+        return (a < b ? 1.0f : 2.0f);
+    }
+
+    public static void testMulThreeArrays(int[] out, int[] ina, int[] inb, int gid) {
+        out[gid] = ina[gid] * inb[gid];
+    }
+
+    public static int testArrayMultiplyZero(int[] array1, int[] array2) {
+        return array1[0] = array2[0] * array2[0];
+    }
+
+    public static int testArrayMultiplyGid(int[] array1, int[] array2, int gid) {
+        return array1[gid] = array2[gid] * array2[gid];
+    }
+
+    public static float testParams3(float c, float d, float e) {
+        return c + d + e;
+    }
+
+    public static int testAssignment() {
+        final int width = 768;
+        final int height = 768;
+        final int maxIterations = 64;
+        return width * height * maxIterations;
+    }
+
+    public static int testSimpleWhile(int i) {
+        int count = 0;
+        int j = 0;
+        final int maxIterations = 64;
+        while (count < maxIterations) {
+            j += count * i;
+            count++;
+        }
+        return j;
+    }
+
+    public static void testComplexWhile() {
+        float lx = 1;
+        float ly = 2;
+        float zx = lx;
+        float zy = ly;
+        float newzx = 0f;
+        final int maxIterations = 64;
+        int count = 0;
+        while (count < maxIterations && zx * zx + zy * zy < 8) {
+            newzx = zx * zx - zy * zy + lx;
+            zy = 2 * zx * zy + ly;
+            zx = newzx;
+            count++;
+        }
+    }
+
+    public static void testMandel(int[] rgb, int[] pallette, float xoffset, float yoffset, float scale, int gid) {
+        final int width = 768;
+        final int height = 768;
+        final int maxIterations = 64;
+        float lx = (((gid % width * scale) - ((scale / 2) * width)) / width) + xoffset;
+        float ly = (((gid / width * scale) - ((scale / 2) * height)) / height) + yoffset;
+        int count = 0;
+        float zx = lx;
+        float zy = ly;
+        float newzx = 0f;
+        /**
+         * Iterate until the algorithm converges or until maxIterations are reached.
+         */
+        while (count < maxIterations && zx * zx + zy * zy < 8) {
+            newzx = zx * zx - zy * zy + lx;
+            zy = 2 * zx * zy + ly;
+            zx = newzx;
+            count++;
+        }
+        rgb[gid] = pallette[count];
+    }
+
+    public static void testMandelSimple(int[] rgb, int[] pallette, float xoffset, float yoffset, float scale, int gid) {
+        final int width = 768;
+        final int height = width;
+        final int maxIterations = 64;
+        float lx = (((gid % width * scale) - ((scale / 2) * width)) / width) + xoffset;
+        float ly = (((gid / width * scale) - ((scale / 2) * height)) / height) + yoffset;
+        int count = 0;
+        float zx = lx;
+        float zy = ly;
+        float newzx = 0f;
+        /**
+         * Iterate until the algorithm converges or until maxIterations are reached.
+         */
+        while (count < maxIterations && zx * zx + zy * zy < 8) {
+            newzx = zx * zx - zy * zy + lx;
+            zy = 2 * zx * zy + ly;
+            zx = newzx;
+            count++;
+        }
+        rgb[gid] = pallette[count];
+    }
+
+    public static void testMandel2(int[] rgb, int[] pallette, int xoffseti, int yoffseti, int scalei, int gid) {
+        final int width = 768;
+        final int height = 768;
+        final int maxIterations = 64;
+        float xoffset = xoffseti;
+        float yoffset = yoffseti;
+        float scale = scalei;
+        float lx = (((gid % width * scale) - ((scale / 2) * width)) / width) + xoffset;
+        float ly = (((gid / width * scale) - ((scale / 2) * height)) / height) + yoffset;
+        int count = 0;
+        float zx = lx;
+        float zy = ly;
+        float newzx = 0f;
+        /**
+         * Iterate until the algorithm converges or until maxIterations are reached.
+         */
+        while (count < maxIterations && zx * zx + zy * zy < 8) {
+            newzx = zx * zx - zy * zy + lx;
+            zy = 2 * zx * zy + ly;
+            zx = newzx;
+            count++;
+        }
+        rgb[gid] = pallette[count];
+    }
+
+    public static int testArrayLocalVariable(int gid, int[] array) {
+        int foo = 198;
+        return array[gid + foo];
+    }
+
+    public static int testArrayReturnFirstElement(int[] array) {
+        return array[0];
+    }
+
+    public static int testArrayReturnIthElement(int i, int[] array) {
+        return array[i];
+    }
+
+    public static void simpleIf(int[] out, int[] in, int gid) {
+        if (gid > 9) {
+            out[gid] = in[gid] * in[gid];
+        }
+    }
+
+    public static int danglingElse(int a) {
+        return (a > 5) ? (a + 7) : (a - 3);
+    }
+
+    public static int danglingElse2(int a, int b) {
+        if (a > 5) {
+            return (a + 7 * (b - 4 + a));
+        } else {
+            return (a - 3 + b * 3 * a + 5);
+        }
+    }
+
+    public static int danglingElse3(int a, int b) {
+        int val;
+        if (a > 5) {
+            val = (a + 7 * (b - 4 + a));
+        } else {
+            val = (a - 3 + b * 3 * a + 5);
+        }
+        return val + a;
+    }
+
+    public static void intSquaresTernary(int[] out, int[] in, int gid) {
+        int val = in[gid] * in[gid];
+        val = (val % 2 == 1 ? val + 1 : val);
+        out[gid] = val;
+    }
+
+    private void test(String snippet) {
+        StructuredGraph graph = parse(snippet);
+        HSAILCompilationResult compResult = HSAILCompilationResult.getHSAILCompilationResult(graph);
+        compResult.dumpCompilationResult();
+    }
+
+    public static void nBodySpill(float[] inxyz, float[] outxyz, float[] invxyz, float[] outvxyz, int gid) {
+        final int bodies = 8;
+        final float delT = .005f;
+        final float espSqr = 1.0f;
+        final float mass = 5f;
+        final int count = bodies * 3;
+        final int globalId = gid * 3;
+        float accx = 0.f;
+        float accy = 0.f;
+        float accz = 0.f;
+        for (int i = 0; i < count; i += 3) {
+            final float dx = inxyz[i + 0] - inxyz[globalId + 0];
+            final float dy = inxyz[i + 1] - inxyz[globalId + 1];
+            final float dz = inxyz[i + 2] - inxyz[globalId + 2];
+            final float invDist = (float) (1.0 / (Math.sqrt((dx * dx) + (dy * dy) + (dz * dz) + espSqr)));
+            accx += mass * invDist * invDist * invDist * dx;
+            accy += mass * invDist * invDist * invDist * dy;
+            accz += mass * invDist * invDist * invDist * dz;
+        }
+        accx *= delT;
+        accy *= delT;
+        accz *= delT;
+        outxyz[globalId + 0] = inxyz[globalId + 0] + (invxyz[globalId + 0] * delT) + (accx * .5f * delT);
+        outxyz[globalId + 1] = inxyz[globalId + 1] + (invxyz[globalId + 1] * delT) + (accy * .5f * delT);
+        outxyz[globalId + 2] = inxyz[globalId + 2] + (invxyz[globalId + 2] * delT) + (accz * .5f * delT);
+        outvxyz[globalId + 0] = invxyz[globalId + 0] + accx;
+        outvxyz[globalId + 1] = invxyz[globalId + 1] + accy;
+        outvxyz[globalId + 2] = invxyz[globalId + 2] + accz;
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/CallTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.*;
+
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+
+/**
+ * Tests direct method calls.
+ */
+public class CallTest extends GraalKernelTester {
+
+    static final int width = 768;
+    static final int height = width;
+    private int iterations = 100;
+    static final int range = width * height;
+    @Result public float[] inArray = new float[range];
+
+    public static int foo(int gid, int i) {
+        if (gid < 25) {
+            return gid * i;
+        } else {
+            return gid - i;
+        }
+    }
+
+    public void run(float[] inArray1, int gid) {
+        for (int i = 0; i < iterations; i++) {
+            inArray1[gid] = foo(gid, i);
+        }
+    }
+
+    @Override
+    public void runTest() {
+        dispatchMethodKernel(range, inArray);
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/FcompUnorderedTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.*;
+
+import com.oracle.graal.compiler.hsail.test.infra.*;
+
+/**
+ * This was a version of Mandel Test that happened to generate a Nan and so was useful for testing
+ * ordered and unordered comparison. However, we should probably replace this with a test (or set of
+ * tests) that is more focussed on Nan and comparisons.
+ */
+public class FcompUnorderedTest extends GraalKernelTester {
+
+    static final int initialWidth = 5;
+    static final int initialHeight = initialWidth;
+    static final int range = 25;
+    @Result private int[] rgb = new int[range];
+    private float[] lxresult = new float[range];
+
+    public static void run(int[] rgb, float xoffset, float yoffset, float scale, int gid) {
+        final int width = initialWidth;
+        final int height = initialHeight;
+        final int maxIterations = 64;
+        float lx = (((gid % width * scale) - ((scale / 2) * width)) / width) + xoffset;
+        float ly = (((gid / width * scale) - ((scale / 2) * height)) / height) + yoffset;
+        int count = 0;
+        float zx = lx;
+        float zy = ly;
+        float newzx = 0f;
+        /**
+         * Iterate until the algorithm converges or until maxIterations are reached.
+         */
+        while (count < maxIterations && zx < 8) {
+            newzx = zx * zx - zy * zy + lx;
+            zy = 2 * zx * zy + ly;
+            zx = newzx;
+            count++;
+        }
+        rgb[gid] = count;
+    }
+
+    void setupPalette(int[] in) {
+        for (int i = 0; i < in.length; i++) {
+            in[i] = i;
+        }
+    }
+
+    @Override
+    public void runTest() {
+        int[] palette = new int[256];
+        setupPalette(palette);
+        for (int i = 0; i < range; i++) {
+            lxresult[i] = -1;
+        }
+        /*
+         * Call it for a range, specifying testmethod args (but not the fields it uses or the gid
+         * argument).
+         */
+        dispatchMethodKernel(range, rgb, 1.0f, 1.0f, 1.0f);
+    }
+
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/FloatConvertTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import java.util.*;
+import org.junit.*;
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+
+/**
+ * Tests floating point comparison.
+ */
+public class FloatConvertTest extends GraalKernelTester {
+
+    static final int size = 128;
+    static final float[] inputFloat = new float[size];
+    static final double[] inputDouble = new double[size];
+    @Result static final float[] outputFloat = new float[size];
+    @Result static final double[] outputDouble = new double[size];
+    static float[] seedFloat = new float[size];
+    {
+        for (int i = 0; i < seedFloat.length; i++) {
+            seedFloat[i] = (float) Math.random();
+        }
+    }
+    static double[] seedDouble = new double[size];
+    {
+        for (int i = 0; i < seedDouble.length; i++) {
+            seedDouble[i] = Math.random();
+        }
+    }
+
+    public static void run(float[] inFloat, double[] inDouble, float[] outFloat, double[] outDouble, int gid) {
+        outFloat[gid] = (float) inDouble[gid];
+        outDouble[gid] = inFloat[gid];
+    }
+
+    @Override
+    public void runTest() {
+        System.arraycopy(seedDouble, 0, inputDouble, 0, seedDouble.length);
+        Arrays.fill(outputDouble, 0f);
+        System.arraycopy(seedFloat, 0, inputFloat, 0, seedFloat.length);
+        Arrays.fill(outputFloat, 0f);
+        dispatchMethodKernel(64, inputFloat, inputDouble, outputFloat, outputDouble);
+    }
+
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/FloatDivPrecisionTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+import org.junit.Test;
+
+/**
+ * This test (originally derived from a discrepancy seen in Mandel) showed a difference in the
+ * division answers when run on Bonaire hardware (compared to Java).
+ */
+public class FloatDivPrecisionTest extends GraalKernelTester {
+
+    static final int width = 768;
+    static final int height = width;
+    static final int range = width * height;
+    @Result private float[] floatResult = new float[range];
+
+    public static void run(float[] floatOut, int gid) {
+        floatOut[gid] = gid / (float) width;
+    }
+
+    @Override
+    public void runTest() {
+        dispatchMethodKernel(range, floatResult);
+
+    }
+
+    /**
+     * Allows subclass to override what FP equality means for this particular unit test.
+     * 
+     */
+    @Override
+    public boolean isEqualsFP(double first, double second) {
+        return Math.abs(first - second) == 0;
+    }
+
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/FloatSqrtTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import java.util.*;
+import org.junit.*;
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+
+/**
+ * Tests floating point square root.
+ */
+public class FloatSqrtTest extends GraalKernelTester {
+
+    static final int size = 128;
+    static final float[] input = new float[size];
+    @Result static final float[] output = new float[size];
+    static float[] seed = new float[size];
+    {
+        for (int i = 0; i < seed.length; i++) {
+            seed[i] = (float) Math.random();
+        }
+
+    }
+
+    public static void run(float[] input1, float[] output1, int gid) {
+        output1[gid] = (float) Math.sqrt(input1[gid]);
+    }
+
+    @Override
+    public void runTest() {
+        System.arraycopy(seed, 0, input, 0, seed.length);
+        Arrays.fill(output, 0f);
+        dispatchMethodKernel(64, input, output);
+    }
+
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntAddIndexTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests array element addition.
+ */
+public class IntAddIndexTest extends StaticMethodThreeIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     */
+    public static void run(int[] out, int[] ina, int[] inb, int gid) {
+        int outIdx = gid + ina[0] - 1;
+        out[outIdx] = ina[gid] + inb[gid];
+    }
+
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntAddTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests integer addition.
+ */
+public class IntAddTest extends StaticMethodThreeIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     * 
+     */
+    public static void run(int[] out, int[] ina, int[] inb, int gid) {
+        out[gid] = ina[gid] + inb[gid];
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntDivTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests integer division.
+ */
+public class IntDivTest extends StaticMethodThreeIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     * 
+     * @param out
+     * @param ina
+     * @param inb
+     * @param gid
+     */
+    public static void run(int[] out, int[] ina, int[] inb, int gid) {
+        out[gid] = inb[gid] / ina[gid];
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntDoubledTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests doubling an integer value.
+ */
+public class IntDoubledTest extends StaticMethodTwoIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     * 
+     * @param out
+     * @param in
+     * @param gid
+     */
+    public static void run(int[] out, int[] in, int gid) {
+        out[gid] = in[gid] + in[gid];
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntFloatConvertTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import java.util.*;
+
+import com.oracle.graal.compiler.hsail.test.infra.*;
+
+/**
+ * Tests integer to float conversion.
+ */
+public class IntFloatConvertTest extends GraalKernelTester {
+
+    static final int size = 128;
+    static final int[] inputInt = new int[size];
+    static final double[] inputDouble = new double[size];
+    @Result static final int[] outputInt = new int[size];
+    @Result static final double[] outputDouble = new double[size];
+    static int[] seedInt = new int[size];
+    {
+        for (int i = 0; i < seedInt.length; i++) {
+            seedInt[i] = (int) Math.random();
+        }
+    }
+    static double[] seedDouble = new double[size];
+    {
+        for (int i = 0; i < seedDouble.length; i++) {
+            seedDouble[i] = Math.random();
+        }
+    }
+
+    public static void run(int[] inInt, double[] inDouble, int[] outInt, double[] outDouble, int gid) {
+        outInt[gid] = (int) inDouble[gid];
+        outDouble[gid] = inInt[gid];
+    }
+
+    @Override
+    public void runTest() {
+        System.arraycopy(seedDouble, 0, inputDouble, 0, seedDouble.length);
+        Arrays.fill(outputDouble, 0);
+        System.arraycopy(seedInt, 0, inputInt, 0, seedInt.length);
+        Arrays.fill(outputInt, 0);
+        dispatchMethodKernel(64, inputInt, inputDouble, outputInt, outputDouble);
+    }
+
+    public void test() {
+        super.testGeneratedHsail();
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntLongConvertTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import java.util.*;
+import org.junit.*;
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+
+/**
+ * Tests integer to long conversion.
+ */
+public class IntLongConvertTest extends GraalKernelTester {
+
+    static final int size = 128;
+    static final int[] inputInt = new int[size];
+    static final long[] inputLong = new long[size];
+    @Result static final int[] outputInt = new int[size];
+    @Result static final long[] outputLong = new long[size];
+    static int[] seedInt = new int[size];
+    {
+        for (int i = 0; i < seedInt.length; i++) {
+            seedInt[i] = (int) Math.random();
+        }
+    }
+    static long[] seedLong = new long[size];
+    {
+        for (int i = 0; i < seedLong.length; i++) {
+            seedLong[i] = (long) Math.random();
+        }
+    }
+
+    public static void run(int[] inInt, long[] inLong, int[] outInt, long[] outLong, int gid) {
+        outInt[gid] = (int) inLong[gid];
+        outLong[gid] = inInt[gid];
+    }
+
+    @Override
+    public void runTest() {
+        System.arraycopy(seedLong, 0, inputLong, 0, seedLong.length);
+        Arrays.fill(outputLong, 0);
+        System.arraycopy(seedInt, 0, inputInt, 0, seedInt.length);
+        Arrays.fill(outputInt, 0);
+        dispatchMethodKernel(64, inputInt, inputLong, outputInt, outputLong);
+    }
+
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntModTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests modulo operation.
+ */
+public class IntModTest extends StaticMethodThreeIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     * 
+     * @param out
+     * @param ina
+     * @param inb
+     * @param gid
+     */
+    public static void run(int[] out, int[] ina, int[] inb, int gid) {
+        out[gid] = inb[gid] % ina[gid];
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntMulTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests array multiplication.
+ */
+public class IntMulTest extends StaticMethodThreeIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     * 
+     * @param out
+     * @param ina
+     * @param inb
+     * @param gid
+     */
+    public static void run(int[] out, int[] ina, int[] inb, int gid) {
+        out[gid] = ina[gid] * inb[gid];
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntSqrAddTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests array addition and multiplication.
+ */
+public class IntSqrAddTest extends StaticMethodThreeIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     * 
+     * @param out
+     * @param ina
+     * @param inb
+     * @param gid
+     */
+    public static void run(int[] out, int[] ina, int[] inb, int gid) {
+        out[gid] = (ina[gid] * ina[gid]) + inb[gid];
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntSquaredGidCmpTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests comparison operation and array multiplication.
+ */
+public class IntSquaredGidCmpTest extends StaticMethodTwoIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter
+     * 
+     * @param out
+     * @param in
+     * @param gid
+     */
+    public static void run(int[] out, int[] in, int gid) {
+        if (gid > 9) {
+            out[gid] = in[gid] * in[gid];
+        }
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntSquaredTernaryTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests conditionals, modulo arithmetic, and addition and multiplications.
+ */
+public class IntSquaredTernaryTest extends StaticMethodTwoIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing By convention the gid is the last parameter.
+     * 
+     * @param out
+     * @param in
+     * @param gid
+     */
+    public static void run(int[] out, int[] in, int gid) {
+        int val = in[gid] * in[gid];
+        val = (val % 2 == 1 ? val + 1 : val);
+        out[gid] = val;
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntSquaredTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests squaring an array element.
+ */
+public class IntSquaredTest extends StaticMethodTwoIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     * 
+     * @param out
+     * @param in
+     * @param gid
+     */
+    public static void run(int[] out, int[] in, int gid) {
+        out[gid] = in[gid] * in[gid];
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntSubTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests subtracting one array element from another.
+ */
+public class IntSubTest extends StaticMethodThreeIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     * 
+     * @param out
+     * @param ina
+     * @param inb
+     * @param gid
+     */
+    public static void run(int[] out, int[] ina, int[] inb, int gid) {
+        out[gid] = ina[gid] - inb[gid];
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/IntSumArrayTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests iteratively summing the elements of an array.
+ */
+public class IntSumArrayTest extends StaticMethodTwoIntArrays {
+
+    /**
+     * The static "kernel" method we will be testing. By convention the gid is the last parameter.
+     * 
+     * @param out
+     * @param in
+     * @param gid
+     */
+    public static void run(int[] out, int[] in, int gid) {
+        int sum = 0;
+        for (int n : in) {
+            sum += n;
+        }
+        out[gid] = sum;
+    }
+
+    @Test
+    public void test() {
+        super.testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/StaticDoubleSpillTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.compiler.hsail.test;
+
+import java.util.*;
+
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+import org.junit.Test;
+
+/**
+ * Tests the spilling of double variables into memory.
+ */
+public class StaticDoubleSpillTest extends GraalKernelTester {
+
+    static final int size = 100;
+    private double[] in = new double[size * 400];
+    @Result private double[] out = new double[size * 400];
+
+    public static void run(double[] out, double[] in, int gid) {
+        int id = gid;
+        int step = 20;
+        double sum0;
+        double sum1;
+        double sum2;
+        double sum3;
+        double sum4;
+        double sum5;
+        double sum6;
+        double sum7;
+        double sum8;
+        double sum9;
+        double sum10;
+        double sum11;
+        double sum12;
+        double sum13;
+        double sum14;
+        double sum15;
+        double sum16;
+        double sum17;
+        double sum18;
+        double sum19;
+        sum0 = sum1 = sum2 = sum3 = sum4 = sum5 = sum6 = sum7 = sum8 = sum9 = 0;
+        sum10 = sum11 = sum12 = sum13 = sum14 = sum15 = sum16 = sum17 = sum18 = sum19 = 0;
+        for (int i = 0; i < size; i += step) {
+            sum0 += in[i + 0];
+            sum1 += in[i + 1];
+            sum2 += in[i + 2];
+            sum3 += in[i + 3];
+            sum4 += in[i + 4];
+            sum5 += in[i + 5];
+            sum6 += in[i + 6];
+            sum7 += in[i + 7];
+            sum8 += in[i + 8];
+            sum9 += in[i + 9];
+            sum10 += in[i + 0];
+            sum11 += in[i + 1];
+            sum12 += in[i + 2];
+            sum13 += in[i + 3];
+            sum14 += in[i + 4];
+            sum15 += in[i + 5];
+            sum16 += in[i + 6];
+            sum17 += in[i + 7];
+            sum18 += in[i + 8];
+            sum19 += in[i + 9];
+        }
+        out[id * step + 0] = sum0;
+        out[id * step + 1] = sum1;
+        out[id * step + 2] = sum2;
+        out[id * step + 3] = sum3;
+        out[id * step + 4] = sum4;
+        out[id * step + 5] = sum5;
+        out[id * step + 6] = sum6;
+        out[id * step + 7] = sum7;
+        out[id * step + 8] = sum8;
+        out[id * step + 9] = sum9;
+        out[id * step + 10] = sum10;
+        out[id * step + 11] = sum11;
+        out[id * step + 12] = sum12;
+        out[id * step + 13] = sum13;
+        out[id * step + 14] = sum14;
+        out[id * step + 15] = sum15;
+        out[id * step + 16] = sum16;
+        out[id * step + 17] = sum17;
+        out[id * step + 18] = sum18;
+        out[id * step + 19] = sum19;
+    }
+
+    @Override
+    public void runTest() {
+        /**
+         * Call it for a range, specifying testmethod args (but not the fields it uses or the gid
+         * argument).
+         * 
+         */
+        Arrays.fill(out, 0f);
+        Arrays.fill(in, 0f);
+        dispatchMethodKernel(size, out, in);
+    }
+
+    // Marked to only run on hardware until simulator spill bug is fixed.
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/StaticIntSpillTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.compiler.hsail.test;
+
+import java.util.*;
+
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+import org.junit.Test;
+
+/**
+ * Tests the spilling of integers into memory.
+ */
+public class StaticIntSpillTest extends GraalKernelTester {
+
+    static final int size = 100;
+    private int[] in = new int[size * 400];
+    @Result private int[] out = new int[size * 400];
+
+    public static void run(int[] out, int[] in, int gid) {
+        int id = gid;
+        int step = 20;
+        int sum0;
+        int sum1;
+        int sum2;
+        int sum3;
+        int sum4;
+        int sum5;
+        int sum6;
+        int sum7;
+        int sum8;
+        int sum9;
+        sum0 = sum1 = sum2 = sum3 = sum4 = sum5 = sum6 = sum7 = sum8 = sum9 = 0;
+        for (int i = 0; i < size; i += step) {
+            sum0 += in[i + 0];
+            sum1 += in[i + 1];
+            sum2 += in[i + 2];
+            sum3 += in[i + 3];
+            sum4 += in[i + 4];
+            sum5 += in[i + 5];
+            sum6 += in[i + 6];
+            sum7 += in[i + 7];
+            sum8 += in[i + 8];
+            sum9 += in[i + 9];
+        }
+        out[id * step + 0] = sum0;
+        out[id * step + 1] = sum1;
+        out[id * step + 2] = sum2;
+        out[id * step + 3] = sum3;
+        out[id * step + 4] = sum4;
+        out[id * step + 5] = sum5;
+        out[id * step + 6] = sum6;
+        out[id * step + 7] = sum7;
+        out[id * step + 8] = sum8;
+        out[id * step + 9] = sum9;
+    }
+
+    @Override
+    public void runTest() {
+        /**
+         * Call it for a range, specifying testmethod args (but not the fields it uses or the gid
+         * argument).
+         * 
+         */
+        Arrays.fill(out, 0);
+        Arrays.fill(in, 0);
+        dispatchMethodKernel(size, out, in);
+    }
+
+    // Marked to only run on hardware until simulator spill bug is fixed.
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/StaticMandelTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+import org.junit.Test;
+
+/**
+ * Unit test that simulates the Mandelbrot application. The run method here is a static method
+ * version of the original mandel kernel and the invoke parameters are for the starting point of the
+ * mandel demo. Note: this will likely not pass the junit test on real hardware, but should pass on
+ * the simulator.
+ */
+public class StaticMandelTest extends GraalKernelTester {
+
+    static final int initWidth = 768;
+    static final int initHeight = initWidth;
+    static final int maxIterations = 64;
+    static final int range = initWidth * initHeight;
+    @Result private int[] rgb = new int[range];
+
+    public static void run(int[] rgb, int[] pallette, float xoffset, float yoffset, float scale, int gid) {
+        final int width = initWidth;
+        final int height = initHeight;
+        float lx = (((gid % width * scale) - ((scale / 2) * width)) / width) + xoffset;
+        float ly = (((gid / width * scale) - ((scale / 2) * height)) / height) + yoffset;
+        int count = 0;
+        float zx = lx;
+        float zy = ly;
+        float newzx = 0f;
+
+        // Iterate until the algorithm converges or until maxIterations are reached.
+        while (count < maxIterations && zx * zx + zy * zy < 8) {
+            newzx = zx * zx - zy * zy + lx;
+            zy = 2 * zx * zy + ly;
+            zx = newzx;
+            count++;
+        }
+        rgb[gid] = pallette[count];
+    }
+
+    void setupPalette(int[] in) {
+        for (int i = 0; i < in.length; i++) {
+            in[i] = i;
+        }
+    }
+
+    @Override
+    public void runTest() {
+        int[] palette = new int[256];
+        setupPalette(palette);
+        /**
+         * Call it for a range, specifying testmethod args (but not the fields it uses or the gid
+         * argument).
+         */
+        dispatchMethodKernel(range, rgb, palette, -1f, 0f, 3f);
+    }
+
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/StaticMethod16InArraysTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import org.junit.Test;
+
+/**
+ * Tests the addition of elements from sixteen input arrays.
+ */
+public class StaticMethod16InArraysTest extends StaticMethodTwoIntArrays {
+
+    @Override
+    void setupArrays(int[] in) {
+        for (int i = 0; i < num; i++) {
+            in[i] = i;
+            outArray[i] = -i;
+        }
+    }
+
+    public static void run(int[] out, int[] ina, int[] inb, int[] inc, int[] ind, int[] ine, int[] inf, int[] ing, int[] inh, int[] ini, int[] inj, int[] ink, int[] inl, int[] inm, int[] inn,
+                    int[] ino, int[] inp, int gid) {
+        out[gid] = ina[gid] + inb[gid] + inc[gid] + ind[gid] + ine[gid] + inf[gid] + ing[gid] + inh[gid] + ini[gid] + inj[gid] + ink[gid] + inl[gid] + inm[gid] + inn[gid] + ino[gid] + inp[gid];
+    }
+
+    @Override
+    public void runTest() {
+        int[] inArray = new int[num];
+        setupArrays(inArray);
+        /**
+         * DumpArrayParameters(inArray); Call it for a range, specifying testmethod args (but not
+         * the fields it uses or the gid argument). Will put output in outArray.
+         */
+        dispatchMethodKernel(num, outArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray, inArray);
+    }
+
+    /**
+     * This test fails because we don't have correct logic to handle more input parameters than
+     * there are registers.
+     */
+    @Test(expected = java.lang.ClassCastException.class)
+    public void test() {
+        testGeneratedHsail();
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/StaticMethodThreeIntArrays.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+/**
+ * Superclass that initializes two input arrays and one output array. Derived by some of the other
+ * test cases that take two arrays as input parameters.
+ */
+public abstract class StaticMethodThreeIntArrays extends StaticMethodTwoIntArrays {
+
+    void setupArrays(int[] in1, int[] in2) {
+        for (int i = 0; i < num; i++) {
+            in1[i] = i + 1;
+            in2[i] = in1[i] + 10;
+            outArray[i] = -i;
+        }
+    }
+
+    @Override
+    public void runTest() {
+        int[] inArray1 = new int[num];
+        int[] inArray2 = new int[num];
+        setupArrays(inArray1, inArray2);
+
+        /**
+         * DumpArrayParameters(inArray); Call it for a range, specifying testmethod args (but not
+         * the fields it uses or the gid argument). Will put output in outArray.
+         */
+        dispatchMethodKernel(num, outArray, inArray1, inArray2);
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/StaticMethodTwoIntArrays.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+
+/**
+ * Superclass that initializes one input array and one output array. Derived by some of the other
+ * test cases that take one array as input and write to an output array.
+ */
+public abstract class StaticMethodTwoIntArrays extends GraalKernelTester {
+
+    static final int num = 20;
+    @Result protected int[] outArray = new int[num];
+
+    void setupArrays(int[] in) {
+        for (int i = 0; i < num; i++) {
+            in[i] = i;
+            outArray[i] = -i;
+        }
+    }
+
+    @Override
+    public void runTest() {
+        int[] inArray = new int[num];
+        setupArrays(inArray);
+        /**
+         * DumpArrayParameters(inArray); Call it for a range, specifying testmethod args (but not
+         * the fields it uses or the gid argument). Will put output in outArray.
+         */
+        dispatchMethodKernel(num, outArray, inArray);
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/StaticNBodySpillTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import java.util.*;
+
+import org.junit.*;
+
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+
+/**
+ * This version of NBody causes Graal to generate register spilling code.
+ */
+public class StaticNBodySpillTest extends GraalKernelTester {
+
+    static final int bodies = 5;
+    static final float delT = .005f;
+    static final float espSqr = 1.0f;
+    static final float mass = 5f;
+    static final int width = 768;
+    static final int height = 768;
+    // Positions xy and z of bodies.
+    @Result private float[] inxyz = new float[bodies * 3];
+    // Positions xy and z of bodies.
+    @Result private float[] outxyz = new float[bodies * 3]; // positions xy and z of bodies
+    // Velocity component of x,y and z of bodies.
+    @Result private float[] invxyz = new float[bodies * 3];
+    @Result private float[] outvxyz = new float[bodies * 3];
+    static float[] seedxyz = new float[bodies * 3];
+    {
+        final float maxDist = width / 4;
+        for (int body = 0; body < (bodies * 3); body += 3) {
+            final float theta = (float) (Math.random() * Math.PI * 2);
+            final float phi = (float) (Math.random() * Math.PI * 2);
+            final float radius = (float) (Math.random() * maxDist);
+            seedxyz[body + 0] = (float) (radius * Math.cos(theta) * Math.sin(phi)) + width / 2;
+            seedxyz[body + 1] = (float) (radius * Math.sin(theta) * Math.sin(phi)) + height / 2;
+            seedxyz[body + 2] = (float) (radius * Math.cos(phi));
+        }
+    }
+
+    public static void run(float[] inxyz, float[] outxyz, float[] invxyz, float[] outvxyz, int gid) {
+        final int count = bodies * 3;
+        final int globalId = gid * 3;
+        float accx = 0.f;
+        float accy = 0.f;
+        float accz = 0.f;
+        for (int i = 0; i < count; i += 3) {
+            final float dx = inxyz[i + 0] - inxyz[globalId + 0];
+            final float dy = inxyz[i + 1] - inxyz[globalId + 1];
+            final float dz = inxyz[i + 2] - inxyz[globalId + 2];
+            final float invDist = (float) (1.0 / (Math.sqrt((dx * dx) + (dy * dy) + (dz * dz) + espSqr)));
+            accx += mass * invDist * invDist * invDist * dx;
+            accy += mass * invDist * invDist * invDist * dy;
+            accz += mass * invDist * invDist * invDist * dz;
+        }
+        accx *= delT;
+        accy *= delT;
+        accz *= delT;
+        outxyz[globalId + 0] = inxyz[globalId + 0] + (invxyz[globalId + 0] * delT) + (accx * .5f * delT);
+        outxyz[globalId + 1] = inxyz[globalId + 1] + (invxyz[globalId + 1] * delT) + (accy * .5f * delT);
+        outxyz[globalId + 2] = inxyz[globalId + 2] + (invxyz[globalId + 2] * delT) + (accz * .5f * delT);
+        outvxyz[globalId + 0] = invxyz[globalId + 0] + accx;
+        outvxyz[globalId + 1] = invxyz[globalId + 1] + accy;
+        outvxyz[globalId + 2] = invxyz[globalId + 2] + accz;
+    }
+
+    @Override
+    public void runTest() {
+        System.arraycopy(seedxyz, 0, inxyz, 0, seedxyz.length);
+        Arrays.fill(outxyz, 0f);
+        Arrays.fill(outvxyz, 0f);
+        Arrays.fill(invxyz, 0f);
+        dispatchMethodKernel(bodies, inxyz, outxyz, invxyz, outvxyz);
+    }
+
+    // Marked to only run on hardware until simulator spill bug is fixed.
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail.test/src/com/oracle/graal/compiler/hsail/test/StaticNBodyTest.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail.test;
+
+import java.util.*;
+
+import org.junit.*;
+import com.oracle.graal.compiler.hsail.test.infra.GraalKernelTester;
+
+/**
+ * Unit test of NBody demo app.
+ */
+public class StaticNBodyTest extends GraalKernelTester {
+
+    static final int bodies = 1024;
+    static final float delT = .005f;
+    static final float espSqr = 1.0f;
+    static final float mass = 5f;
+    static final int width = 768;
+    static final int height = 768;
+    // Positions xy and z of bodies.
+    @Result private float[] inxyz = new float[bodies * 3];
+    // Positions xy and z of bodies.
+    @Result private float[] outxyz = new float[bodies * 3];
+    // Velocity component of x,y and z of bodies.
+    @Result private float[] invxyz = new float[bodies * 3];
+    @Result private float[] outvxyz = new float[bodies * 3];
+    static float[] seedxyz = new float[bodies * 3];
+    {
+        final float maxDist = width / 4;
+        for (int body = 0; body < (bodies * 3); body += 3) {
+            final float theta = (float) (Math.random() * Math.PI * 2);
+            final float phi = (float) (Math.random() * Math.PI * 2);
+            final float radius = (float) (Math.random() * maxDist);
+            seedxyz[body + 0] = (float) (radius * Math.cos(theta) * Math.sin(phi)) + width / 2;
+            seedxyz[body + 1] = (float) (radius * Math.sin(theta) * Math.sin(phi)) + height / 2;
+            seedxyz[body + 2] = (float) (radius * Math.cos(phi));
+        }
+    }
+
+    public static void run(float[] inxyz, float[] outxyz, float[] invxyz, float[] outvxyz, int gid) {
+        final int count = bodies * 3;
+        final int globalId = gid * 3;
+        float accx = 0.f;
+        float accy = 0.f;
+        float accz = 0.f;
+        for (int i = 0; i < count; i += 3) {
+            final float dx = inxyz[i + 0] - inxyz[globalId + 0];
+            final float dy = inxyz[i + 1] - inxyz[globalId + 1];
+            final float dz = inxyz[i + 2] - inxyz[globalId + 2];
+            final float invDist = (float) (1.0 / (Math.sqrt((dx * dx) + (dy * dy) + (dz * dz) + espSqr)));
+            accx += mass * invDist * invDist * invDist * dx;
+            accy += mass * invDist * invDist * invDist * dy;
+            accz += mass * invDist * invDist * invDist * dz;
+        }
+        accx *= delT;
+        accy *= delT;
+        accz *= delT;
+        outxyz[globalId + 0] = inxyz[globalId + 0] + (invxyz[globalId + 0] * delT) + (accx * .5f * delT);
+        outxyz[globalId + 1] = inxyz[globalId + 1] + (invxyz[globalId + 1] * delT) + (accy * .5f * delT);
+        outxyz[globalId + 2] = inxyz[globalId + 2] + (invxyz[globalId + 2] * delT) + (accz * .5f * delT);
+        outvxyz[globalId + 0] = invxyz[globalId + 0] + accx;
+        outvxyz[globalId + 1] = invxyz[globalId + 1] + accy;
+        outvxyz[globalId + 2] = invxyz[globalId + 2] + accz;
+    }
+
+    @Override
+    public void runTest() {
+        System.arraycopy(seedxyz, 0, inxyz, 0, seedxyz.length);
+        Arrays.fill(outxyz, 0f);
+        Arrays.fill(outvxyz, 0f);
+        Arrays.fill(invxyz, 0f);
+        dispatchMethodKernel(bodies, inxyz, outxyz, invxyz, outvxyz);
+    }
+
+    @Test
+    public void test() {
+        testGeneratedHsail();
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/CompileAndDispatch.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail;
+
+/**
+ * Interface for compiling a Java program to HSAIL and dispatching execution to the GPU or an HSAIL
+ * simulator.
+ */
+public interface CompileAndDispatch {
+
+    Object createKernel(Class<?> consumerClass);
+
+    boolean dispatchKernel(Object kernel, int jobSize, Object[] args);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/ForEachToGraal.java	Tue Jul 09 11:21:06 2013 +0200
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.graal.compiler.hsail;
+
+import com.oracle.graal.api.code.CompilationResult;
+import java.lang.reflect.Method;
+
+import com.amd.okra.OkraContext;
+import com.amd.okra.OkraKernel;
+import com.oracle.graal.hotspot.HotSpotGraalRuntime;
+import com.oracle.graal.hotspot.HotSpotVMConfig;
+import com.oracle.graal.hotspot.amd64.AMD64HotSpotRuntime;
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.api.runtime.Graal;
+import com.oracle.graal.java.GraphBuilderConfiguration;
+import com.oracle.graal.java.GraphBuilderPhase;
+import com.oracle.graal.nodes.StructuredGraph;
+import com.oracle.graal.nodes.java.MethodCallTargetNode;
+import com.oracle.graal.nodes.spi.Replacements;
+import com.oracle.graal.phases.OptimisticOptimizations;
+import com.oracle.graal.graph.Node;
+import com.oracle.graal.graph.iterators.*;
+import com.oracle.graal.compiler.target.Backend;
+import com.oracle.graal.nodes.spi.GraalCodeCacheProvider;
+import com.oracle.graal.debug.*;
+
+/**
+ * Implements compile and dispatch of Java code containing lambda constructs. Currently only used by
+ * JDK interception code that offloads to the GPU.
+ */
+public class ForEachToGraal implements CompileAndDispatch {
+
+    protected final GraalCodeCacheProvider runtime;
+    protected final Replacements replacements;
+    protected final Backend backend;
+
+    public ForEachToGraal() {
+        this.runtime = Graal.getRequiredCapability(GraalCodeCacheProvider.class);
+        this.replacements = Graal.getRequiredCapability(Replacements.class);
+        this.backend = Graal.getRequiredCapability(Backend.class);
+    }
+
+    private static CompilationResult getCompiledLambda(Class consumerClass) {
+        /**
+         * Find the accept() method in the IntConsumer, then use Graal API to find the target lambda
+         * that accept will call.
+         */
+        Method[] icMethods = consumerClass.getMethods();
+        Method acceptMethod = null;
+        for (Method m : icMethods) {
+            if (m.getName().equals("accept") && acceptMethod == null) {
+                acceptMethod = m;
+            }
+        }
+        HotSpotVMConfig config = HotSpotGraalRuntime.graalRuntime().getConfig();
+        AMD64HotSpotRuntime hsruntime = new AMD64HotSpotRuntime(config, HotSpotGraalRuntime.graalRuntime());
+        ResolvedJavaMethod rm = hsruntime.lookupJavaMethod(acceptMethod);
+        StructuredGraph graph = new StructuredGraph(rm);
+        new GraphBuilderPhase(hsruntime, GraphBuilderConfiguration.getEagerDefault(), OptimisticOptimizations.ALL).apply(graph);
+        NodeIterable<Node> nin = graph.getNodes();
+        ResolvedJavaMethod lambdaMethod = null;
+        for (Node n : nin) {
+            if (n instanceof MethodCallTargetNode) {
+                lambdaMethod = ((MethodCallTargetNode) n).targetMethod();
+                Debug.log("target ... " + lambdaMethod);
+                break;
+            }
+        }
+        if (lambdaMethod == null) {
+            // Did not find call in Consumer.accept.
+            Debug.log("Should not Reach here, did not find call in accept()");
+            return null;
+        }
+        // Now that we have the target lambda, compile it.
+        HSAILCompilationResult hsailCompResult = HSAILCompilationResult.getHSAILCompilationResult(lambdaMethod);
+        if (hsailCompResult != null) {
+            hsailCompResult.dumpCompilationResult();
+        }
+        return hsailCompResult.getCompilationResult();
+    }
+
+    // Implementations of the CompileAndDispatch interface.
+    @Override
+    public Object createKernel(Class<?> consumerClass) {
+        try {
+            CompilationResult result = getCompiledLambda(consumerClass);
+            if (result != null) {
+                String code = new String(new String(result.getTargetCode(), 0, result.getTargetCodeSize()));
+                OkraContext okraContext = new OkraContext();
+                OkraKernel okraKernel = new OkraKernel(okraContext, code, "&run");
+                if (okraKernel.isValid()) {
+                    return okraKernel;
+                }
+            }
+        } catch (Throwable e) {
+            // Note: Graal throws Errors. We want to revert to regular Java in these cases.
+            Debug.log("WARNING:Graal compilation failed.");
+            e.printStackTrace();
+            return null;
+        }
+        // If we got this far, return null.
+        return null;
+    }
+
+    @Override
+    public boolean dispatchKernel(Object kernel, int jobSize, Object[] args) {
+        if (!(kernel instanceof OkraKernel)) {
+            Debug.log("unknown kernel for dispatchKernel");
+            return false;
+        }
+        OkraKernel okraKernel = (OkraKernel) kernel;
+        okraKernel.setLaunchAttributes(jobSize);
+        int status = okraKernel.dispatchWithArgs(args);
+        return (status == 0);
+    }
+}