diff --git a/com.amd.aparapi/src/java/com/amd/aparapi/internal/kernel/KernelRunner.java b/com.amd.aparapi/src/java/com/amd/aparapi/internal/kernel/KernelRunner.java
new file mode 100644
index 0000000000000000000000000000000000000000..d99809e9c3353db214658321b92e41b731dea54a
--- /dev/null
+++ b/com.amd.aparapi/src/java/com/amd/aparapi/internal/kernel/KernelRunner.java
@@ -0,0 +1,1775 @@
+/*
+Copyright (c) 2010-2011, Advanced Micro Devices, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+disclaimer in the documentation and/or other materials provided with the distribution.
+
+Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+If you use the software (in whole or in part), you shall adhere to all applicable U.S., European, and other export
+laws, including but not limited to the U.S. Export Administration Regulations ("EAR"), (15 C.F.R. Sections 730 through
+774), and E.U. Council Regulation (EC) No 1334/2000 of 22 June 2000. Further, pursuant to Section 740.6 of the EAR,
+you hereby certify that, except pursuant to a license granted by the United States Department of Commerce Bureau of
+Industry and Security or as otherwise permitted pursuant to a License Exception under the U.S. Export Administration
+Regulations ("EAR"), you will not (1) export, re-export or release to a national of a country in Country Groups D:1,
+E:1 or E:2 any restricted technology, software, or source code you receive hereunder, or (2) export to Country Groups
+D:1, E:1 or E:2 the direct product of such technology or software, if such foreign produced direct product is subject
+to national security controls as identified on the Commerce Control List (currently found in Supplement 1 to Part 774
+of EAR). For the most current Country Group listings, or for additional information about the EAR or your obligations
+under those regulations, please refer to the U.S. Bureau of Industry and Security's website at http://www.bis.doc.gov/.
+
+*/
+package com.amd.aparapi.internal.kernel;
+
+import com.amd.aparapi.*;
+import com.amd.aparapi.Kernel.Constant;
+import com.amd.aparapi.Kernel.*;
+import com.amd.aparapi.device.*;
+import com.amd.aparapi.internal.annotation.*;
+import com.amd.aparapi.internal.exception.*;
+import com.amd.aparapi.internal.instruction.InstructionSet.*;
+import com.amd.aparapi.internal.jni.*;
+import com.amd.aparapi.internal.model.*;
+import com.amd.aparapi.internal.util.*;
+import com.amd.aparapi.internal.writer.*;
+import com.amd.aparapi.opencl.*;
+
+import java.lang.reflect.*;
+import java.nio.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.ForkJoinPool.*;
+import java.util.logging.*;
+
+/**
+ * The class is responsible for executing <code>Kernel</code> implementations. <br/>
+ *
+ * The <code>KernelRunner</code> is the real workhorse for Aparapi. Each <code>Kernel</code> instance creates a single
+ * <code>KernelRunner</code> to encapsulate state and to help coordinate interactions between the <code>Kernel</code>
+ * and it's execution logic.<br/>
+ *
+ * The <code>KernelRunner</code> is created <i>lazily</i> as a result of calling <code>Kernel.execute()</code>. A this
+ * time the <code>ExecutionMode</code> is consulted to determine the default requested mode. This will dictate how
+ * the <code>KernelRunner</code> will attempt to execute the <code>Kernel</code>
+ *
+ * @see com.amd.aparapi.Kernel#execute(int _globalSize)
+ *
+ * @author gfrost
+ *
+ */
+public class KernelRunner extends KernelRunnerJNI{
+
+ public static boolean BINARY_CACHING_DISABLED = false;
+
+ private static final int MINIMUM_ARRAY_SIZE = 1;
+
+ /** @see #getCurrentPass() */
+ @UsedByJNICode public static final int PASS_ID_PREPARING_EXECUTION = -2;
+ /** @see #getCurrentPass() */
+ @UsedByJNICode public static final int PASS_ID_COMPLETED_EXECUTION = -1;
+ @UsedByJNICode public static final int CANCEL_STATUS_FALSE = 0;
+ @UsedByJNICode public static final int CANCEL_STATUS_TRUE = 1;
+ private static final String CODE_GEN_ERROR_MARKER = CodeGenException.class.getName();
+
+ private static Logger logger = Logger.getLogger(Config.getLoggerName());
+
+ private long jniContextHandle = 0;
+
+ private final Kernel kernel;
+
+ private Entrypoint entryPoint;
+
+ private int argc;
+
+ // may be read by a thread other than the control thread, hence volatile
+ private volatile boolean executing;
+
+ // may be read by a thread other than the control thread, hence volatile
+ private volatile int passId = PASS_ID_PREPARING_EXECUTION;
+
+ /**
+ * A direct ByteBuffer used for asynchronous intercommunication between java and JNI C code.
+ *
+ * <p>
+ * At present this is a 4 byte buffer to be interpreted as an int[1], used for passing from java to C a single integer interpreted as a cancellation indicator.
+ */
+ private final ByteBuffer inBufferRemote;
+ private final IntBuffer inBufferRemoteInt;
+
+ /** A direct ByteBuffer used for asynchronous intercommunication between java and JNI C code.
+ * <p>
+ * At present this is a 4 byte buffer to be interpreted as an int[1], used for passing from C to java a single integer interpreted as a
+ * the current pass id.
+ */
+ private final ByteBuffer outBufferRemote;
+ private final IntBuffer outBufferRemoteInt;
+
+ private boolean isFallBack = false; // If isFallBack, rebuild the kernel (necessary?)
+
+ private static final ForkJoinWorkerThreadFactory lowPriorityThreadFactory = new ForkJoinWorkerThreadFactory(){
+ @Override public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
+ ForkJoinWorkerThread newThread = ForkJoinPool.defaultForkJoinWorkerThreadFactory.newThread(pool);
+ newThread.setPriority(Thread.MIN_PRIORITY);
+ return newThread;
+ }
+ };
+
+ private static final ForkJoinPool threadPool = new ForkJoinPool(Runtime.getRuntime().availableProcessors(),
+ lowPriorityThreadFactory, null, false);
+ private static HashMap<Class<? extends Kernel>, String> openCLCache = new HashMap<>();
+ private static LinkedHashSet<String> seenBinaryKeys = new LinkedHashSet<>();
+
+ /**
+ * Create a KernelRunner for a specific Kernel instance.
+ *
+ * @param _kernel
+ */
+ public KernelRunner(Kernel _kernel) {
+ kernel = _kernel;
+
+ inBufferRemote = ByteBuffer.allocateDirect(4);
+ outBufferRemote = ByteBuffer.allocateDirect(4);
+
+ inBufferRemote.order(ByteOrder.nativeOrder());
+ outBufferRemote.order(ByteOrder.nativeOrder());
+
+ inBufferRemoteInt = inBufferRemote.asIntBuffer();
+ outBufferRemoteInt = outBufferRemote.asIntBuffer();
+
+ KernelManager.instance(); // ensures static initialization of KernelManager
+ }
+
+ /**
+ * @see Kernel#cleanUpArrays().
+ */
+ public void cleanUpArrays() {
+ if (args != null && kernel.isRunningCL()) {
+ for (KernelArg arg : args) {
+ if ((arg.getType() & KernelRunnerJNI.ARG_ARRAY) != 0) {
+ Field field = arg.getField();
+ if (field != null && field.getType().isArray() && !Modifier.isFinal(field.getModifiers())) {
+ field.setAccessible(true);
+ Class<?> componentType = field.getType().getComponentType();
+ Object newValue = Array.newInstance(componentType, MINIMUM_ARRAY_SIZE);
+ try {
+ field.set(kernel, newValue);
+ }
+ catch (IllegalAccessException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+ }
+ kernel.execute(0);
+ } else if (kernel.isRunningCL()) {
+ logger.log(Level.SEVERE, "KernelRunner#cleanUpArrays() could not execute as no args available (Kernel has not been executed?)");
+ }
+ }
+
+ /**
+ * <code>Kernel.dispose()</code> delegates to <code>KernelRunner.dispose()</code> which delegates to <code>disposeJNI()</code> to actually close JNI data structures.<br/>
+ *
+ * @see KernelRunnerJNI#disposeJNI(long)
+ */
+ public synchronized void dispose() {
+ if (kernel.isRunningCL()) {
+ disposeJNI(jniContextHandle);
+ seenBinaryKeys.clear();
+ }
+ // We are using a shared pool, so there's no need no shutdown it when kernel is disposed
+ // threadPool.shutdownNow();
+ }
+
+ private Set<String> capabilitiesSet;
+
+ boolean hasFP64Support() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return (capabilitiesSet.contains(OpenCL.CL_KHR_FP64));
+ }
+
+ boolean hasSelectFPRoundingModeSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_SELECT_FPROUNDING_MODE);
+ }
+
+ boolean hasGlobalInt32BaseAtomicsSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_GLOBAL_INT32_BASE_ATOMICS);
+ }
+
+ boolean hasGlobalInt32ExtendedAtomicsSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_GLOBAL_INT32_EXTENDED_ATOMICS);
+ }
+
+ boolean hasLocalInt32BaseAtomicsSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_LOCAL_INT32_BASE_ATOMICS);
+ }
+
+ boolean hasLocalInt32ExtendedAtomicsSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_LOCAL_INT32_EXTENDED_ATOMICS);
+ }
+
+ boolean hasInt64BaseAtomicsSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_INT64_BASE_ATOMICS);
+ }
+
+ boolean hasInt64ExtendedAtomicsSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_INT64_EXTENDED_ATOMICS);
+ }
+
+ boolean has3DImageWritesSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_3D_IMAGE_WRITES);
+ }
+
+ boolean hasByteAddressableStoreSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_BYTE_ADDRESSABLE_SUPPORT);
+ }
+
+ boolean hasFP16Support() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_FP16);
+ }
+
+ boolean hasGLSharingSupport() {
+ if (capabilitiesSet == null) {
+ throw new IllegalStateException("Capabilities queried before they were initialized");
+ }
+ return capabilitiesSet.contains(OpenCL.CL_KHR_GL_SHARING);
+ }
+
+ private static final class FJSafeCyclicBarrier extends CyclicBarrier{
+ FJSafeCyclicBarrier(final int threads) {
+ super(threads);
+ }
+
+ @Override public int await() throws InterruptedException, BrokenBarrierException {
+ class Awaiter implements ManagedBlocker{
+ private int value;
+
+ private boolean released;
+
+ @Override public boolean block() throws InterruptedException {
+ try {
+ value = superAwait();
+ released = true;
+ return true;
+ } catch (final BrokenBarrierException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override public boolean isReleasable() {
+ return released;
+ }
+
+ int getValue() {
+ return value;
+ }
+ }
+ final Awaiter awaiter = new Awaiter();
+ ForkJoinPool.managedBlock(awaiter);
+ return awaiter.getValue();
+ }
+
+ int superAwait() throws InterruptedException, BrokenBarrierException {
+ return super.await();
+ }
+ }
+
+ // @FunctionalInterface
+ private interface ThreadIdSetter{
+ void set(KernelState kernelState, int globalGroupId, int threadId);
+ }
+
+ /**
+ * Execute using a Java thread pool, or sequentially, or using an alternative algorithm, usually as a result of failing to compile or execute OpenCL
+ */
+ @SuppressWarnings("deprecation")
+ protected void executeJava(ExecutionSettings _settings, Device device) {
+ if (logger.isLoggable(Level.FINE)) {
+ logger.fine("executeJava: range = " + _settings.range + ", device = " + device);
+ }
+ boolean legacySequentialMode = kernel.getExecutionMode().equals(Kernel.EXECUTION_MODE.SEQ);
+
+ passId = PASS_ID_PREPARING_EXECUTION;
+ _settings.profile.onEvent(ProfilingEvent.PREPARE_EXECUTE);
+
+ try {
+ if (device == JavaDevice.ALTERNATIVE_ALGORITHM) {
+ if (kernel.hasFallbackAlgorithm()) {
+ for (passId = 0; passId < _settings.passes; ++passId) {
+ kernel.executeFallbackAlgorithm(_settings.range, passId);
+ }
+ } else {
+ boolean silently = true; // not having an alternative algorithm is the normal state, and does not need reporting
+ fallBackToNextDevice(_settings, (Exception) null, silently);
+ }
+ } else {
+ final int localSize0 = _settings.range.getLocalSize(0);
+ final int localSize1 = _settings.range.getLocalSize(1);
+ final int localSize2 = _settings.range.getLocalSize(2);
+ final int globalSize1 = _settings.range.getGlobalSize(1);
+ if (legacySequentialMode || device == JavaDevice.SEQUENTIAL) {
+ /**
+ * SEQ mode is useful for testing trivial logic, but kernels which use SEQ mode cannot be used if the
+ * product of localSize(0..3) is >1. So we can use multi-dim ranges but only if the local size is 1 in all dimensions.
+ *
+ * As a result of this barrier is only ever 1 work item wide and probably should be turned into a no-op.
+ *
+ * So we need to check if the range is valid here. If not we have no choice but to punt.
+ */
+ if ((localSize0 * localSize1 * localSize2) > 1) {
+ throw new IllegalStateException("Can't run range with group size >1 sequentially. Barriers would deadlock!");
+ }
+
+ final Kernel kernelClone = kernel.clone();
+ final KernelState kernelState = kernelClone.getKernelState();
+
+ kernelState.setRange(_settings.range);
+ kernelState.setGroupId(0, 0);
+ kernelState.setGroupId(1, 0);
+ kernelState.setGroupId(2, 0);
+ kernelState.setLocalId(0, 0);
+ kernelState.setLocalId(1, 0);
+ kernelState.setLocalId(2, 0);
+ kernelState.setLocalBarrier(new FJSafeCyclicBarrier(1));
+
+ for (passId = 0; passId < _settings.passes; passId++) {
+ if (getCancelState() == CANCEL_STATUS_TRUE) {
+ break;
+ }
+ kernelState.setPassId(passId);
+
+ if (_settings.range.getDims() == 1) {
+ for (int id = 0; id < _settings.range.getGlobalSize(0); id++) {
+ kernelState.setGlobalId(0, id);
+ kernelClone.run();
+ }
+ }
+ else if (_settings.range.getDims() == 2) {
+ for (int x = 0; x < _settings.range.getGlobalSize(0); x++) {
+ kernelState.setGlobalId(0, x);
+
+ for (int y = 0; y < globalSize1; y++) {
+ kernelState.setGlobalId(1, y);
+ kernelClone.run();
+ }
+ }
+ }
+ else if (_settings.range.getDims() == 3) {
+ for (int x = 0; x < _settings.range.getGlobalSize(0); x++) {
+ kernelState.setGlobalId(0, x);
+
+ for (int y = 0; y < globalSize1; y++) {
+ kernelState.setGlobalId(1, y);
+
+ for (int z = 0; z < _settings.range.getGlobalSize(2); z++) {
+ kernelState.setGlobalId(2, z);
+ kernelClone.run();
+ }
+
+ kernelClone.run();
+ }
+ }
+ }
+ }
+ passId = PASS_ID_COMPLETED_EXECUTION;
+ }
+ else {
+ if (device != JavaDevice.THREAD_POOL && kernel.getExecutionMode() != Kernel.EXECUTION_MODE.JTP) {
+ throw new AssertionError("unexpected JavaDevice or EXECUTION_MODE");
+ }
+ final int threads = localSize0 * localSize1 * localSize2;
+ final int numGroups0 = _settings.range.getNumGroups(0);
+ final int numGroups1 = _settings.range.getNumGroups(1);
+ final int globalGroups = numGroups0 * numGroups1 * _settings.range.getNumGroups(2);
+ /**
+ * This joinBarrier is the barrier that we provide for the kernel threads to rendezvous with the current dispatch thread.
+ * So this barrier is threadCount+1 wide (the +1 is for the dispatch thread)
+ */
+ final CyclicBarrier joinBarrier = new FJSafeCyclicBarrier(threads + 1);
+
+ /**
+ * This localBarrier is only ever used by the kernels. If the kernel does not use the barrier the threads
+ * can get out of sync, we promised nothing in JTP mode.
+ *
+ * As with OpenCL all threads within a group must wait at the barrier or none. It is a user error (possible deadlock!)
+ * if the barrier is in a conditional that is only executed by some of the threads within a group.
+ *
+ * Kernel developer must understand this.
+ *
+ * This barrier is threadCount wide. We never hit the barrier from the dispatch thread.
+ */
+ final CyclicBarrier localBarrier = new FJSafeCyclicBarrier(threads);
+
+ final ThreadIdSetter threadIdSetter;
+
+ if (_settings.range.getDims() == 1) {
+ threadIdSetter = new ThreadIdSetter() {
+ @Override
+ public void set(KernelState kernelState, int globalGroupId, int threadId) {
+ // (kernelState, globalGroupId, threadId) ->{
+ kernelState.setLocalId(0, (threadId % localSize0));
+ kernelState.setGlobalId(0, (threadId + (globalGroupId * threads)));
+ kernelState.setGroupId(0, globalGroupId);
+ }
+ };
+ }
+ else if (_settings.range.getDims() == 2) {
+
+ /**
+ * Consider a 12x4 grid of 4*2 local groups
+ * <pre>
+ * threads = 4*2 = 8
+ * localWidth=4
+ * localHeight=2
+ * globalWidth=12
+ * globalHeight=4
+ *
+ * 00 01 02 03 | 04 05 06 07 | 08 09 10 11
+ * 12 13 14 15 | 16 17 18 19 | 20 21 22 23
+ * ------------+-------------+------------
+ * 24 25 26 27 | 28 29 30 31 | 32 33 34 35
+ * 36 37 38 39 | 40 41 42 43 | 44 45 46 47
+ *
+ * 00 01 02 03 | 00 01 02 03 | 00 01 02 03 threadIds : [0..7]*6
+ * 04 05 06 07 | 04 05 06 07 | 04 05 06 07
+ * ------------+-------------+------------
+ * 00 01 02 03 | 00 01 02 03 | 00 01 02 03
+ * 04 05 06 07 | 04 05 06 07 | 04 05 06 07
+ *
+ * 00 00 00 00 | 01 01 01 01 | 02 02 02 02 groupId[0] : 0..6
+ * 00 00 00 00 | 01 01 01 01 | 02 02 02 02
+ * ------------+-------------+------------
+ * 00 00 00 00 | 01 01 01 01 | 02 02 02 02
+ * 00 00 00 00 | 01 01 01 01 | 02 02 02 02
+ *
+ * 00 00 00 00 | 00 00 00 00 | 00 00 00 00 groupId[1] : 0..6
+ * 00 00 00 00 | 00 00 00 00 | 00 00 00 00
+ * ------------+-------------+------------
+ * 01 01 01 01 | 01 01 01 01 | 01 01 01 01
+ * 01 01 01 01 | 01 01 01 01 | 01 01 01 01
+ *
+ * 00 01 02 03 | 08 09 10 11 | 16 17 18 19 globalThreadIds == threadId + groupId * threads;
+ * 04 05 06 07 | 12 13 14 15 | 20 21 22 23
+ * ------------+-------------+------------
+ * 24 25 26 27 | 32[33]34 35 | 40 41 42 43
+ * 28 29 30 31 | 36 37 38 39 | 44 45 46 47
+ *
+ * 00 01 02 03 | 00 01 02 03 | 00 01 02 03 localX = threadId % localWidth; (for globalThreadId 33 = threadId = 01 : 01%4 =1)
+ * 00 01 02 03 | 00 01 02 03 | 00 01 02 03
+ * ------------+-------------+------------
+ * 00 01 02 03 | 00[01]02 03 | 00 01 02 03
+ * 00 01 02 03 | 00 01 02 03 | 00 01 02 03
+ *
+ * 00 00 00 00 | 00 00 00 00 | 00 00 00 00 localY = threadId /localWidth (for globalThreadId 33 = threadId = 01 : 01/4 =0)
+ * 01 01 01 01 | 01 01 01 01 | 01 01 01 01
+ * ------------+-------------+------------
+ * 00 00 00 00 | 00[00]00 00 | 00 00 00 00
+ * 01 01 01 01 | 01 01 01 01 | 01 01 01 01
+ *
+ * 00 01 02 03 | 04 05 06 07 | 08 09 10 11 globalX=
+ * 00 01 02 03 | 04 05 06 07 | 08 09 10 11 groupsPerLineWidth=globalWidth/localWidth (=12/4 =3)
+ * ------------+-------------+------------ groupInset =groupId%groupsPerLineWidth (=4%3 = 1)
+ * 00 01 02 03 | 04[05]06 07 | 08 09 10 11
+ * 00 01 02 03 | 04 05 06 07 | 08 09 10 11 globalX = groupInset*localWidth+localX (= 1*4+1 = 5)
+ *
+ * 00 00 00 00 | 00 00 00 00 | 00 00 00 00 globalY
+ * 01 01 01 01 | 01 01 01 01 | 01 01 01 01
+ * ------------+-------------+------------
+ * 02 02 02 02 | 02[02]02 02 | 02 02 02 02
+ * 03 03 03 03 | 03 03 03 03 | 03 03 03 03
+ *
+ * </pre>
+ * Assume we are trying to locate the id's for #33
+ *
+ */
+ threadIdSetter = new ThreadIdSetter() {
+ @Override
+ public void set(KernelState kernelState, int globalGroupId, int threadId) {
+ // (kernelState, globalGroupId, threadId) ->{
+ kernelState.setLocalId(0, (threadId % localSize0)); // threadId % localWidth = (for 33 = 1 % 4 = 1)
+ kernelState.setLocalId(1, (threadId / localSize0)); // threadId / localWidth = (for 33 = 1 / 4 == 0)
+
+ final int groupInset = globalGroupId % numGroups0; // 4%3 = 1
+ kernelState.setGlobalId(0, ((groupInset * localSize0) + kernelState.getLocalIds()[0])); // 1*4+1=5
+
+ final int completeLines = (globalGroupId / numGroups0) * localSize1;// (4/3) * 2
+ kernelState.setGlobalId(1, (completeLines + kernelState.getLocalIds()[1])); // 2+0 = 2
+ kernelState.setGroupId(0, (globalGroupId % numGroups0));
+ kernelState.setGroupId(1, (globalGroupId / numGroups0));
+ }
+ };
+ }
+ else if (_settings.range.getDims() == 3) {
+ //Same as 2D actually turns out that localId[0] is identical for all three dims so could be hoisted out of conditional code
+ threadIdSetter = new ThreadIdSetter() {
+ @Override
+ public void set(KernelState kernelState, int globalGroupId, int threadId) {
+ // (kernelState, globalGroupId, threadId) ->{
+ kernelState.setLocalId(0, (threadId % localSize0));
+
+ kernelState.setLocalId(1, ((threadId / localSize0) % localSize1));
+
+ // the thread id's span WxHxD so threadId/(WxH) should yield the local depth
+ kernelState.setLocalId(2, (threadId / (localSize0 * localSize1)));
+
+ kernelState.setGlobalId(0, (((globalGroupId % numGroups0) * localSize0) + kernelState.getLocalIds()[0]));
+
+ kernelState.setGlobalId(1,
+ ((((globalGroupId / numGroups0) * localSize1) % globalSize1) + kernelState.getLocalIds()[1]));
+
+ kernelState.setGlobalId(2,
+ (((globalGroupId / (numGroups0 * numGroups1)) * localSize2) + kernelState.getLocalIds()[2]));
+
+ kernelState.setGroupId(0, (globalGroupId % numGroups0));
+ kernelState.setGroupId(1, ((globalGroupId / numGroups0) % numGroups1));
+ kernelState.setGroupId(2, (globalGroupId / (numGroups0 * numGroups1)));
+ }
+ };
+ }
+ else
+ throw new IllegalArgumentException("Expected 1,2 or 3 dimensions, found " + _settings.range.getDims());
+ for (passId = 0; passId < _settings.passes; passId++) {
+ if (getCancelState() == CANCEL_STATUS_TRUE) {
+ break;
+ }
+ /**
+ * Note that we emulate OpenCL by creating one thread per localId (across the group).
+ *
+ * So threadCount == range.getLocalSize(0)*range.getLocalSize(1)*range.getLocalSize(2);
+ *
+ * For a 1D range of 12 groups of 4 we create 4 threads. One per localId(0).
+ *
+ * We also clone the kernel 4 times. One per thread.
+ *
+ * We create local barrier which has a width of 4
+ *
+ * Thread-0 handles localId(0) (global 0,4,8)
+ * Thread-1 handles localId(1) (global 1,5,7)
+ * Thread-2 handles localId(2) (global 2,6,10)
+ * Thread-3 handles localId(3) (global 3,7,11)
+ *
+ * This allows all threads to synchronize using the local barrier.
+ *
+ * Initially the use of local buffers seems broken as the buffers appears to be per Kernel.
+ * Thankfully Kernel.clone() performs a shallow clone of all buffers (local and global)
+ * So each of the cloned kernels actually still reference the same underlying local/global buffers.
+ *
+ * If the kernel uses local buffers but does not use barriers then it is possible for different groups
+ * to see mutations from each other (unlike OpenCL), however if the kernel does not us barriers then it
+ * cannot assume any coherence in OpenCL mode either (the failure mode will be different but still wrong)
+ *
+ * So even JTP mode use of local buffers will need to use barriers. Not for the same reason as OpenCL but to keep groups in lockstep.
+ *
+ **/
+ for (int id = 0; id < threads; id++) {
+ final int threadId = id;
+
+ /**
+ * We clone one kernel for each thread.
+ *
+ * They will all share references to the same range, localBarrier and global/local buffers because the clone is shallow.
+ * We need clones so that each thread can assign 'state' (localId/globalId/groupId) without worrying
+ * about other threads.
+ */
+ final Kernel kernelClone = kernel.clone();
+ final KernelState kernelState = kernelClone.getKernelState();
+ kernelState.setRange(_settings.range);
+ kernelState.setPassId(passId);
+
+ if (threads == 1) {
+ kernelState.disableLocalBarrier();
+ }
+ else {
+ kernelState.setLocalBarrier(localBarrier);
+ }
+
+ threadPool.submit(
+ // () -> {
+ new Runnable() {
+ public void run() {
+ try {
+ for (int globalGroupId = 0; globalGroupId < globalGroups; globalGroupId++) {
+ threadIdSetter.set(kernelState, globalGroupId, threadId);
+ kernelClone.run();
+ }
+ }
+ catch (RuntimeException | Error e) {
+ logger.log(Level.SEVERE, "Execution failed", e);
+ }
+ finally {
+ await(joinBarrier); // This thread will rendezvous with dispatch thread here. This is effectively a join.
+ }
+ }
+ });
+ }
+
+ await(joinBarrier); // This dispatch thread waits for all worker threads here.
+ }
+ passId = PASS_ID_COMPLETED_EXECUTION;
+ } // execution mode == JTP
+ }
+ } finally {
+ passId = PASS_ID_COMPLETED_EXECUTION;
+ }
+ }
+
+ private static void await(CyclicBarrier _barrier) {
+ try {
+ _barrier.await();
+ } catch (final InterruptedException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } catch (final BrokenBarrierException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ private KernelArg[] args = null;
+
+ private boolean usesOopConversion = false;
+
+ /**
+ *
+ * @param arg
+ * @return
+ * @throws AparapiException
+ */
+ private boolean prepareOopConversionBuffer(KernelArg arg) throws AparapiException {
+ usesOopConversion = true;
+ final Class<?> arrayClass = arg.getField().getType();
+ ClassModel c = null;
+ boolean didReallocate = false;
+
+ if (arg.getObjArrayElementModel() == null) {
+ final String tmp = arrayClass.getName().substring(2).replace('/', '.');
+ final String arrayClassInDotForm = tmp.substring(0, tmp.length() - 1);
+
+ if (logger.isLoggable(Level.FINE)) {
+ logger.fine("looking for type = " + arrayClassInDotForm);
+ }
+
+ // get ClassModel of obj array from entrypt.objectArrayFieldsClasses
+ c = entryPoint.getObjectArrayFieldsClasses().get(arrayClassInDotForm);
+ arg.setObjArrayElementModel(c);
+ } else {
+ c = arg.getObjArrayElementModel();
+ }
+ assert c != null : "should find class for elements " + arrayClass.getName();
+
+ final int arrayBaseOffset = UnsafeWrapper.arrayBaseOffset(arrayClass);
+ final int arrayScale = UnsafeWrapper.arrayIndexScale(arrayClass);
+
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("Syncing obj array type = " + arrayClass + " cvtd= " + c.getClassWeAreModelling().getName()
+ + "arrayBaseOffset=" + arrayBaseOffset + " arrayScale=" + arrayScale);
+ }
+
+ int objArraySize = 0;
+ Object newRef = null;
+ try {
+ newRef = arg.getField().get(kernel);
+ objArraySize = Array.getLength(newRef);
+ } catch (final IllegalAccessException e) {
+ throw new AparapiException(e);
+ }
+
+ assert (newRef != null) && (objArraySize != 0) : "no data";
+
+ final int totalStructSize = c.getTotalStructSize();
+ final int totalBufferSize = objArraySize * totalStructSize;
+
+ // allocate ByteBuffer if first time or array changed
+ if ((arg.getObjArrayBuffer() == null) || (newRef != arg.getArray())) {
+ final ByteBuffer structBuffer = ByteBuffer.allocate(totalBufferSize);
+ arg.setObjArrayByteBuffer(structBuffer.order(ByteOrder.LITTLE_ENDIAN));
+ arg.setObjArrayBuffer(arg.getObjArrayByteBuffer().array());
+ didReallocate = true;
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("objArraySize = " + objArraySize + " totalStructSize= " + totalStructSize + " totalBufferSize="
+ + totalBufferSize);
+ }
+ } else {
+ arg.getObjArrayByteBuffer().clear();
+ }
+
+ // copy the fields that the JNI uses
+ arg.setJavaArray(arg.getObjArrayBuffer());
+ arg.setNumElements(objArraySize);
+ arg.setSizeInBytes(totalBufferSize);
+
+ for (int j = 0; j < objArraySize; j++) {
+ int sizeWritten = 0;
+
+ final Object object = UnsafeWrapper.getObject(newRef, arrayBaseOffset + (arrayScale * j));
+ for (int i = 0; i < c.getStructMemberTypes().size(); i++) {
+ final TypeSpec t = c.getStructMemberTypes().get(i);
+ final long offset = c.getStructMemberOffsets().get(i);
+
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("name = " + c.getStructMembers().get(i).getNameAndTypeEntry().getNameUTF8Entry().getUTF8() + " t= "
+ + t);
+ }
+
+ switch (t) {
+ case I: {
+ final int x = UnsafeWrapper.getInt(object, offset);
+ arg.getObjArrayByteBuffer().putInt(x);
+ sizeWritten += t.getSize();
+ break;
+ }
+ case F: {
+ final float x = UnsafeWrapper.getFloat(object, offset);
+ arg.getObjArrayByteBuffer().putFloat(x);
+ sizeWritten += t.getSize();
+ break;
+ }
+ case J: {
+ final long x = UnsafeWrapper.getLong(object, offset);
+ arg.getObjArrayByteBuffer().putLong(x);
+ sizeWritten += t.getSize();
+ break;
+ }
+ case Z: {
+ final boolean x = UnsafeWrapper.getBoolean(object, offset);
+ arg.getObjArrayByteBuffer().put(x == true ? (byte) 1 : (byte) 0);
+ // Booleans converted to 1 byte C chars for opencl
+ sizeWritten += TypeSpec.B.getSize();
+ break;
+ }
+ case B: {
+ final byte x = UnsafeWrapper.getByte(object, offset);
+ arg.getObjArrayByteBuffer().put(x);
+ sizeWritten += t.getSize();
+ break;
+ }
+ case D: {
+ throw new AparapiException("Double not implemented yet");
+ }
+ default:
+ assert true == false : "typespec did not match anything";
+ throw new AparapiException("Unhandled type in buffer conversion");
+ }
+ }
+
+ // add padding here if needed
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("sizeWritten = " + sizeWritten + " totalStructSize= " + totalStructSize);
+ }
+
+ assert sizeWritten <= totalStructSize : "wrote too much into buffer";
+
+ while (sizeWritten < totalStructSize) {
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest(arg.getName() + " struct pad byte = " + sizeWritten + " totalStructSize= " + totalStructSize);
+ }
+ arg.getObjArrayByteBuffer().put((byte) -1);
+ sizeWritten++;
+ }
+ }
+
+ assert arg.getObjArrayByteBuffer().arrayOffset() == 0 : "should be zero";
+
+ return didReallocate;
+ }
+
+ private void extractOopConversionBuffer(KernelArg arg) throws AparapiException {
+ final Class<?> arrayClass = arg.getField().getType();
+ final ClassModel c = arg.getObjArrayElementModel();
+ assert c != null : "should find class for elements: " + arrayClass.getName();
+ assert arg.getArray() != null : "array is null";
+
+ final int arrayBaseOffset = UnsafeWrapper.arrayBaseOffset(arrayClass);
+ final int arrayScale = UnsafeWrapper.arrayIndexScale(arrayClass);
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("Syncing field:" + arg.getName() + ", bb=" + arg.getObjArrayByteBuffer() + ", type = " + arrayClass);
+ }
+
+ int objArraySize = 0;
+ try {
+ objArraySize = Array.getLength(arg.getField().get(kernel));
+ } catch (final IllegalAccessException e) {
+ throw new AparapiException(e);
+ }
+
+ assert objArraySize > 0 : "should be > 0";
+
+ final int totalStructSize = c.getTotalStructSize();
+ // int totalBufferSize = objArraySize * totalStructSize;
+ // assert arg.objArrayBuffer.length == totalBufferSize : "size should match";
+
+ arg.getObjArrayByteBuffer().rewind();
+
+ for (int j = 0; j < objArraySize; j++) {
+ int sizeWritten = 0;
+ final Object object = UnsafeWrapper.getObject(arg.getArray(), arrayBaseOffset + (arrayScale * j));
+ for (int i = 0; i < c.getStructMemberTypes().size(); i++) {
+ final TypeSpec t = c.getStructMemberTypes().get(i);
+ final long offset = c.getStructMemberOffsets().get(i);
+ switch (t) {
+ case I: {
+ // read int value from buffer and store into obj in the array
+ final int x = arg.getObjArrayByteBuffer().getInt();
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("fType = " + t.getShortName() + " x= " + x);
+ }
+ UnsafeWrapper.putInt(object, offset, x);
+ sizeWritten += t.getSize();
+ break;
+ }
+ case F: {
+ final float x = arg.getObjArrayByteBuffer().getFloat();
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("fType = " + t.getShortName() + " x= " + x);
+ }
+ UnsafeWrapper.putFloat(object, offset, x);
+ sizeWritten += t.getSize();
+ break;
+ }
+ case J: {
+ final long x = arg.getObjArrayByteBuffer().getLong();
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("fType = " + t.getShortName() + " x= " + x);
+ }
+ UnsafeWrapper.putLong(object, offset, x);
+ sizeWritten += t.getSize();
+ break;
+ }
+ case Z: {
+ final byte x = arg.getObjArrayByteBuffer().get();
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("fType = " + t.getShortName() + " x= " + x);
+ }
+ UnsafeWrapper.putBoolean(object, offset, (x == 1 ? true : false));
+ // Booleans converted to 1 byte C chars for open cl
+ sizeWritten += TypeSpec.B.getSize();
+ break;
+ }
+ case B: {
+ final byte x = arg.getObjArrayByteBuffer().get();
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("fType = " + t.getShortName() + " x= " + x);
+ }
+ UnsafeWrapper.putByte(object, offset, x);
+ sizeWritten += t.getSize();
+ break;
+ }
+ case D: {
+ throw new AparapiException("Double not implemented yet");
+ }
+ default:
+ assert true == false : "typespec did not match anything";
+ throw new AparapiException("Unhandled type in buffer conversion");
+ }
+ }
+
+ // add padding here if needed
+ if (logger.isLoggable(Level.FINEST)) {
+ logger.finest("sizeWritten = " + sizeWritten + " totalStructSize= " + totalStructSize);
+ }
+
+ assert sizeWritten <= totalStructSize : "wrote too much into buffer";
+
+ while (sizeWritten < totalStructSize) {
+ // skip over pad bytes
+ arg.getObjArrayByteBuffer().get();
+ sizeWritten++;
+ }
+ }
+ }
+
+ private void restoreObjects() throws AparapiException {
+ for (int i = 0; i < argc; i++) {
+ final KernelArg arg = args[i];
+ if ((arg.getType() & ARG_OBJ_ARRAY_STRUCT) != 0) {
+ extractOopConversionBuffer(arg);
+ }
+ }
+ }
+
+ private boolean updateKernelArrayRefs() throws AparapiException {
+ boolean needsSync = false;
+
+ for (int i = 0; i < argc; i++) {
+ final KernelArg arg = args[i];
+ try {
+ if ((arg.getType() & ARG_ARRAY) != 0) {
+ Object newArrayRef;
+ newArrayRef = arg.getField().get(kernel);
+
+ if (newArrayRef == null) {
+ throw new IllegalStateException("Cannot send null refs to kernel, reverting to java");
+ }
+
+ String fieldName = arg.getField().getName();
+ int arrayLength = Array.getLength(newArrayRef);
+ Integer privateMemorySize = ClassModel.getPrivateMemorySizeFromField(arg.getField());
+ if (privateMemorySize == null) {
+ privateMemorySize = ClassModel.getPrivateMemorySizeFromFieldName(fieldName);
+ }
+ if (privateMemorySize != null) {
+ if (arrayLength > privateMemorySize) {
+ throw new IllegalStateException("__private array field " + fieldName + " has illegal length " + arrayLength
+ + " > " + privateMemorySize);
+ }
+ }
+
+ if ((arg.getType() & ARG_OBJ_ARRAY_STRUCT) != 0) {
+ prepareOopConversionBuffer(arg);
+ } else {
+ // set up JNI fields for normal arrays
+ arg.setJavaArray(newArrayRef);
+ arg.setNumElements(arrayLength);
+ arg.setSizeInBytes(arg.getNumElements() * arg.getPrimitiveSize());
+
+ if (((args[i].getType() & ARG_EXPLICIT) != 0) && puts.contains(newArrayRef)) {
+ args[i].setType(args[i].getType() | ARG_EXPLICIT_WRITE);
+ // System.out.println("detected an explicit write " + args[i].name);
+ puts.remove(newArrayRef);
+ }
+ }
+
+ if (newArrayRef != arg.getArray()) {
+ needsSync = true;
+
+ if (logger.isLoggable(Level.FINE)) {
+ logger.fine("saw newArrayRef for " + arg.getName() + " = " + newArrayRef + ", newArrayLen = "
+ + Array.getLength(newArrayRef));
+ }
+ }
+
+ arg.setArray(newArrayRef);
+ assert arg.getArray() != null : "null array ref";
+ } else if ((arg.getType() & ARG_APARAPI_BUFFER) != 0) {
+ // TODO: check if the 2D/3D array is changed.
+ // can Arrays.equals help?
+ needsSync = true; // Always need syn
+ Object buffer = new Object();
+ try {
+ buffer = arg.getField().get(kernel);
+ } catch (IllegalAccessException e) {
+ e.printStackTrace();
+ }
+ int numDims = arg.getNumDims();
+ Object subBuffer = buffer;
+ int[] dims = new int[numDims];
+ for (int d = 0; d < numDims - 1; d++) {
+ dims[d] = Array.getLength(subBuffer);
+ subBuffer = Array.get(subBuffer, 0);
+ }
+ dims[numDims - 1] = Array.getLength(subBuffer);
+ arg.setDims(dims);
+
+ int primitiveSize = getPrimitiveSize(arg.getType());
+ int totalElements = 1;
+ for (int d = 0; d < numDims; d++) {
+ totalElements *= dims[d];
+ }
+ arg.setJavaBuffer(buffer);
+ arg.setSizeInBytes(totalElements * primitiveSize);
+ arg.setArray(buffer);
+ }
+ } catch (final IllegalArgumentException e) {
+ e.printStackTrace();
+ } catch (final IllegalAccessException e) {
+ e.printStackTrace();
+ }
+ }
+ return needsSync;
+ }
+
+ @SuppressWarnings("deprecation")
+ private Kernel executeOpenCL(ExecutionSettings _settings) throws AparapiException {
+
+ // Read the array refs after kernel may have changed them
+ // We need to do this as input to computing the localSize
+ assert args != null : "args should not be null";
+ final boolean needSync = updateKernelArrayRefs();
+ if (needSync && logger.isLoggable(Level.FINE)) {
+ logger.fine("Need to resync arrays on " + kernel);
+ }
+
+ // native side will reallocate array buffers if necessary
+ int returnValue = runKernelJNI(jniContextHandle, _settings.range, needSync, _settings.passes, inBufferRemote, outBufferRemote);
+ if (returnValue != 0) {
+ String reason = "OpenCL execution seems to have failed (runKernelJNI returned " + returnValue + ")";
+ return fallBackToNextDevice(_settings, new AparapiException(reason));
+ }
+
+ if (usesOopConversion == true) {
+ restoreObjects();
+ }
+
+ if (logger.isLoggable(Level.FINE)) {
+ logger.fine("executeOpenCL completed. " + _settings.range);
+ }
+
+ return kernel;
+ }
+
+ @SuppressWarnings("deprecation")
+ synchronized private Kernel fallBackByExecutionMode(ExecutionSettings _settings) {
+ isFallBack = true;
+ if (kernel.hasNextExecutionMode()) {
+ kernel.tryNextExecutionMode();
+ if (logger.isLoggable(Level.WARNING)) {
+ logger.warning("Trying next execution mode " + kernel.getExecutionMode());
+ }
+ } else {
+ kernel.setFallbackExecutionMode();
+ }
+ recreateRange(_settings);
+ return executeInternalInner(_settings);
+ }
+
+ private void recreateRange(ExecutionSettings _settings) {
+ if (_settings.range.isLocalIsDerived() && !_settings.legacyExecutionMode) {
+ Device device = kernel.getTargetDevice();
+ Range result;
+ switch (_settings.range.getDims()) {
+ case 1: {
+ result = Range.create(device, _settings.range.getGlobalSize_0());
+ break;
+ }
+ case 2: {
+ result = Range.create2D(device, _settings.range.getGlobalSize_0(), _settings.range.getGlobalSize_1());
+ break;
+ }
+ case 3: {
+ result = Range.create3D(device, _settings.range.getGlobalSize_0(), _settings.range.getGlobalSize_1(), _settings.range.getGlobalSize_2());
+ break;
+ }
+ default: {
+ throw new AssertionError("Range.getDims() = " + _settings.range.getDims());
+ }
+ }
+ _settings.range = result;
+ }
+ }
+
+ private Kernel fallBackToNextDevice(ExecutionSettings _settings, String _reason) {
+ return fallBackToNextDevice(_settings, new AparapiException(_reason));
+ }
+
+ @SuppressWarnings("deprecation")
+ synchronized private Kernel fallBackToNextDevice(ExecutionSettings _settings, Exception _exception) {
+ return fallBackToNextDevice(_settings, _exception, false);
+ }
+
+ @SuppressWarnings("deprecation")
+ synchronized private Kernel fallBackToNextDevice(ExecutionSettings _settings, Exception _exception, boolean _silently) {
+ isFallBack = true;
+ _settings.profile.onEvent(ProfilingEvent.EXECUTED);
+ if (_settings.legacyExecutionMode) {
+ if (!_silently && logger.isLoggable(Level.WARNING)) {
+ logger.warning("Execution mode " + kernel.getExecutionMode() + " failed for " + kernel + ": " + _exception.getMessage());
+ _exception.printStackTrace();
+ }
+ return fallBackByExecutionMode(_settings);
+ } else {
+ KernelPreferences preferences = KernelManager.instance().getPreferences(kernel);
+ if (!_silently && logger.isLoggable(Level.WARNING)) {
+ logger.warning("Device failed for " + kernel + ": " + _exception.getMessage());
+ }
+
+ preferences.markPreferredDeviceFailed();
+
+// Device nextDevice = preferences.getPreferredDevice(kernel);
+//
+// if (nextDevice == null) {
+// if (!_silently && logger.isLoggable(Level.SEVERE)) {
+// logger.severe("No Devices left to try, giving up");
+// }
+// throw new RuntimeException(_exception);
+// }
+ if (!_silently && logger.isLoggable(Level.WARNING)) {
+ _exception.printStackTrace();
+ logger.warning("Trying next device: " + describeDevice());
+ }
+ }
+
+ recreateRange(_settings);
+ return executeInternalInner(_settings);
+ }
+
+ @SuppressWarnings("deprecation")
+ public synchronized Kernel execute(String _entrypoint, final Range _range, final int _passes) {
+ executing = true;
+ try {
+ clearCancelMultiPass();
+ KernelProfile profile = KernelManager.instance().getProfile(kernel.getClass());
+ KernelPreferences preferences = KernelManager.instance().getPreferences(kernel);
+ boolean legacyExecutionMode = kernel.getExecutionMode() != Kernel.EXECUTION_MODE.AUTO;
+
+ ExecutionSettings settings = new ExecutionSettings(preferences, profile, _entrypoint, _range, _passes, legacyExecutionMode);
+ // Two Kernels of the same class share the same KernelPreferences object, and since failure (fallback) generally mutates
+ // the preferences object, we must lock it. Note this prevents two Kernels of the same class executing simultaneously.
+ synchronized (preferences) {
+ return executeInternalOuter(settings);
+ }
+ } finally {
+ executing = false;
+ clearCancelMultiPass();
+ }
+ }
+
+ private synchronized Kernel executeInternalOuter(ExecutionSettings _settings) {
+ try {
+ return executeInternalInner(_settings);
+ } finally {
+ if (kernel.isAutoCleanUpArrays() &&_settings.range.getGlobalSize_0() != 0) {
+ cleanUpArrays();
+ }
+ }
+ }
+
+ @SuppressWarnings("deprecation")
+ private synchronized Kernel executeInternalInner(ExecutionSettings _settings) {
+
+ if (_settings.range == null) {
+ throw new IllegalStateException("range can't be null");
+ }
+
+ EXECUTION_MODE requestedExecutionMode = kernel.getExecutionMode();
+
+ if (requestedExecutionMode.isOpenCL() && _settings.range.getDevice() != null && !(_settings.range.getDevice() instanceof OpenCLDevice)) {
+ fallBackToNextDevice(_settings, "OpenCL EXECUTION_MODE was requested but Device supplied was not an OpenCLDevice");
+ }
+
+ Device device = _settings.range.getDevice();
+ boolean userSpecifiedDevice = true;
+ if (device == null) {
+ userSpecifiedDevice = false;
+ if (!_settings.legacyExecutionMode) {
+ device = _settings.preferences.getPreferredDevice(kernel);
+ if (device == null) {
+ // the default fallback when KernelPreferences has run out of options is JTP
+ device = JavaDevice.THREAD_POOL;
+ }
+ } else {
+ if (requestedExecutionMode == EXECUTION_MODE.JTP) {
+ device = JavaDevice.THREAD_POOL;
+ } else if (requestedExecutionMode == EXECUTION_MODE.SEQ) {
+ device = JavaDevice.SEQUENTIAL;
+ }
+ }
+ } else {
+ boolean compatible = isDeviceCompatible(device);
+ if (!compatible) {
+ throw new AssertionError("user supplied Device incompatible with current EXECUTION_MODE or getTargetDevice(); device = "
+ + device.getShortDescription() + "; kernel = " + kernel);
+ }
+ }
+
+ try {
+ OpenCLDevice openCLDevice = device instanceof OpenCLDevice ? (OpenCLDevice) device : null;
+
+ int jniFlags = 0;
+ // for legacy reasons use old logic where Kernel.EXECUTION_MODE is not AUTO
+ if (_settings.legacyExecutionMode && !userSpecifiedDevice && requestedExecutionMode.isOpenCL()) {
+ if (requestedExecutionMode.equals(EXECUTION_MODE.GPU)) {
+ // Get the best GPU
+ openCLDevice = (OpenCLDevice) KernelManager.DeprecatedMethods.bestGPU();
+ jniFlags |= JNI_FLAG_USE_GPU; // this flag might be redundant now.
+ if (openCLDevice == null) {
+ return fallBackToNextDevice(_settings, "GPU request can't be honored, no GPU device");
+ }
+ } else if (requestedExecutionMode.equals(EXECUTION_MODE.ACC)) {
+ // Get the best ACC
+ openCLDevice = (OpenCLDevice) KernelManager.DeprecatedMethods.bestACC();
+ jniFlags |= JNI_FLAG_USE_ACC; // this flag might be redundant now.
+ if (openCLDevice == null) {
+ return fallBackToNextDevice(_settings, "ACC request can't be honored, no ACC device");
+ }
+ } else {
+ // We fetch the first CPU device
+ openCLDevice = (OpenCLDevice) KernelManager.DeprecatedMethods.firstDevice(Device.TYPE.CPU);
+ if (openCLDevice == null) {
+ return fallBackToNextDevice(_settings, "CPU request can't be honored, no CPU device");
+ }
+ }
+ } else {
+ if (device.getType() == Device.TYPE.GPU) {
+ jniFlags |= JNI_FLAG_USE_GPU; // this flag might be redundant now.
+ } else if (device.getType() == Device.TYPE.ACC) {
+ jniFlags |= JNI_FLAG_USE_ACC; // this flag might be redundant now.
+ }
+ }
+ if (device == null && openCLDevice != null) {
+ device = openCLDevice;
+ }
+ assert device != null : "No device available";
+ _settings.profile.onStart(device);
+ /* for backward compatibility reasons we still honor execution mode */
+ boolean isOpenCl = requestedExecutionMode.isOpenCL() || device instanceof OpenCLDevice;
+ if (isOpenCl) {
+ if ((entryPoint == null) || (isFallBack)) {
+ if (entryPoint == null) {
+ try {
+ final ClassModel classModel = ClassModel.createClassModel(kernel.getClass());
+ entryPoint = classModel.getEntrypoint(_settings.entrypoint, kernel);
+ _settings.profile.onEvent(ProfilingEvent.CLASS_MODEL_BUILT);
+ } catch (final Exception exception) {
+ _settings.profile.onEvent(ProfilingEvent.CLASS_MODEL_BUILT);
+ return fallBackToNextDevice(_settings, exception);
+ }
+ }
+
+ if ((entryPoint != null)) {
+ synchronized (Kernel.class) { // This seems to be needed because of a race condition uncovered with issue #68 http://code.google.com/p/aparapi/issues/detail?id=68
+
+ // jniFlags |= (Config.enableProfiling ? JNI_FLAG_ENABLE_PROFILING : 0);
+ // jniFlags |= (Config.enableProfilingCSV ? JNI_FLAG_ENABLE_PROFILING_CSV | JNI_FLAG_ENABLE_PROFILING : 0);
+ // jniFlags |= (Config.enableVerboseJNI ? JNI_FLAG_ENABLE_VERBOSE_JNI : 0);
+ // jniFlags |= (Config.enableVerboseJNIOpenCLResourceTracking ? JNI_FLAG_ENABLE_VERBOSE_JNI_OPENCL_RESOURCE_TRACKING :0);
+ // jniFlags |= (kernel.getExecutionMode().equals(Kernel.EXECUTION_MODE.GPU) ? JNI_FLAG_USE_GPU : 0);
+ // Init the device to check capabilities before emitting the
+ // code that requires the capabilities.
+ jniContextHandle = initJNI(kernel, openCLDevice, jniFlags); // openCLDevice will not be null here
+ _settings.profile.onEvent(ProfilingEvent.INIT_JNI);
+ } // end of synchronized! issue 68
+
+ if (jniContextHandle == 0) {
+ return fallBackToNextDevice(_settings, "initJNI failed to return a valid handle");
+ }
+
+ final String extensions = getExtensionsJNI(jniContextHandle);
+ capabilitiesSet = new HashSet<String>();
+
+ final StringTokenizer strTok = new StringTokenizer(extensions);
+ while (strTok.hasMoreTokens()) {
+ capabilitiesSet.add(strTok.nextToken());
+ }
+
+ if (logger.isLoggable(Level.FINE)) {
+ logger.fine("Capabilities initialized to :" + capabilitiesSet.toString());
+ }
+
+ if (entryPoint.requiresDoublePragma() && !hasFP64Support()) {
+ return fallBackToNextDevice(_settings, "FP64 required but not supported");
+ }
+
+ if (entryPoint.requiresByteAddressableStorePragma() && !hasByteAddressableStoreSupport()) {
+ return fallBackToNextDevice(_settings, "Byte addressable stores required but not supported");
+ }
+
+ final boolean all32AtomicsAvailable = hasGlobalInt32BaseAtomicsSupport()
+ && hasGlobalInt32ExtendedAtomicsSupport() && hasLocalInt32BaseAtomicsSupport()
+ && hasLocalInt32ExtendedAtomicsSupport();
+
+ if (entryPoint.requiresAtomic32Pragma() && !all32AtomicsAvailable) {
+
+ return fallBackToNextDevice(_settings, "32 bit Atomics required but not supported");
+ }
+
+ String openCL;
+ synchronized (openCLCache) {
+ openCL = openCLCache.get(kernel.getClass());
+ if (openCL == null) {
+ try {
+ openCL = KernelWriter.writeToString(entryPoint);
+ if (logger.isLoggable(Level.INFO)) {
+ logger.info(openCL);
+ }
+ else if (Config.enableShowGeneratedOpenCL) {
+ System.out.println(openCL);
+ }
+ _settings.profile.onEvent(ProfilingEvent.OPENCL_GENERATED);
+ openCLCache.put(kernel.getClass(), openCL);
+ }
+ catch (final CodeGenException codeGenException) {
+ openCLCache.put(kernel.getClass(), CODE_GEN_ERROR_MARKER);
+ _settings.profile.onEvent(ProfilingEvent.OPENCL_GENERATED);
+ return fallBackToNextDevice(_settings, codeGenException);
+ }
+ }
+ else {
+ if (openCL.equals(CODE_GEN_ERROR_MARKER)) {
+ _settings.profile.onEvent(ProfilingEvent.OPENCL_GENERATED);
+ boolean silently = true; // since we must have already reported the CodeGenException
+ return fallBackToNextDevice(_settings, null, silently);
+ }
+ }
+ }
+
+ // Send the string to OpenCL to compile it, or if the compiled binary is already cached on JNI side just empty string to use cached binary
+ long handle;
+ if (BINARY_CACHING_DISABLED) {
+ handle = buildProgramJNI(jniContextHandle, openCL, "");
+ } else {
+ synchronized (seenBinaryKeys) {
+ String binaryKey = kernel.getClass().getName() + ":" + device.getDeviceId();
+ if (seenBinaryKeys.contains(binaryKey)) {
+ // use cached binary
+ logger.log(Level.INFO, "reusing cached binary for " + binaryKey);
+ handle = buildProgramJNI(jniContextHandle, "", binaryKey);
+ }
+ else {
+ // create and cache binary
+ logger.log(Level.INFO, "compiling new binary for " + binaryKey);
+ handle = buildProgramJNI(jniContextHandle, openCL, binaryKey);
+ seenBinaryKeys.add(binaryKey);
+ }
+ }
+ }
+ _settings.profile.onEvent(ProfilingEvent.OPENCL_COMPILED);
+ if (handle == 0) {
+ return fallBackToNextDevice(_settings, "OpenCL compile failed");
+ }
+
+ args = new KernelArg[entryPoint.getReferencedFields().size()];
+ int i = 0;
+
+ for (final Field field : entryPoint.getReferencedFields()) {
+ try {
+ field.setAccessible(true);
+ args[i] = new KernelArg();
+ args[i].setName(field.getName());
+ args[i].setField(field);
+ if ((field.getModifiers() & Modifier.STATIC) == Modifier.STATIC) {
+ args[i].setType(args[i].getType() | ARG_STATIC);
+ }
+
+ final Class<?> type = field.getType();
+ if (type.isArray()) {
+
+ if (field.getAnnotation(Local.class) != null || args[i].getName().endsWith(Kernel.LOCAL_SUFFIX)) {
+ args[i].setType(args[i].getType() | ARG_LOCAL);
+ } else if ((field.getAnnotation(Constant.class) != null)
+ || args[i].getName().endsWith(Kernel.CONSTANT_SUFFIX)) {
+ args[i].setType(args[i].getType() | ARG_CONSTANT);
+ } else {
+ args[i].setType(args[i].getType() | ARG_GLOBAL);
+ }
+ if (isExplicit()) {
+ args[i].setType(args[i].getType() | ARG_EXPLICIT);
+ }
+ // for now, treat all write arrays as read-write, see bugzilla issue 4859
+ // we might come up with a better solution later
+ args[i].setType(args[i].getType()
+ | (entryPoint.getArrayFieldAssignments().contains(field.getName()) ? (ARG_WRITE | ARG_READ) : 0));
+ args[i].setType(args[i].getType()
+ | (entryPoint.getArrayFieldAccesses().contains(field.getName()) ? ARG_READ : 0));
+ // args[i].type |= ARG_GLOBAL;
+
+ if (type.getName().startsWith("[L")) {
+ args[i].setArray(null); // will get updated in updateKernelArrayRefs
+ args[i].setType(args[i].getType()
+ | (ARG_ARRAY | ARG_OBJ_ARRAY_STRUCT | ARG_WRITE | ARG_READ));
+
+ if (logger.isLoggable(Level.FINE)) {
+ logger.fine("tagging " + args[i].getName() + " as (ARG_ARRAY | ARG_OBJ_ARRAY_STRUCT | ARG_WRITE | ARG_READ)");
+ }
+ } else if (type.getName().startsWith("[[")) {
+
+ try {
+ setMultiArrayType(args[i], type);
+ } catch (AparapiException e) {
+ return fallBackToNextDevice(_settings, "failed to set kernel arguement "
+ + args[i].getName() + ". Aparapi only supports 2D and 3D arrays.");
+ }
+ } else {
+
+ args[i].setArray(null); // will get updated in updateKernelArrayRefs
+ args[i].setType(args[i].getType() | ARG_ARRAY);
+
+ args[i].setType(args[i].getType() | (type.isAssignableFrom(float[].class) ? ARG_FLOAT : 0));
+ args[i].setType(args[i].getType() | (type.isAssignableFrom(int[].class) ? ARG_INT : 0));
+ args[i].setType(args[i].getType() | (type.isAssignableFrom(boolean[].class) ? ARG_BOOLEAN : 0));
+ args[i].setType(args[i].getType() | (type.isAssignableFrom(byte[].class) ? ARG_BYTE : 0));
+ args[i].setType(args[i].getType() | (type.isAssignableFrom(char[].class) ? ARG_CHAR : 0));
+ args[i].setType(args[i].getType() | (type.isAssignableFrom(double[].class) ? ARG_DOUBLE : 0));
+ args[i].setType(args[i].getType() | (type.isAssignableFrom(long[].class) ? ARG_LONG : 0));
+ args[i].setType(args[i].getType() | (type.isAssignableFrom(short[].class) ? ARG_SHORT : 0));
+
+ // arrays whose length is used will have an int arg holding
+ // the length as a kernel param
+ if (entryPoint.getArrayFieldArrayLengthUsed().contains(args[i].getName())) {
+ args[i].setType(args[i].getType() | ARG_ARRAYLENGTH);
+ }
+
+ if (type.getName().startsWith("[L")) {
+ args[i].setType(args[i].getType() | (ARG_OBJ_ARRAY_STRUCT | ARG_WRITE | ARG_READ));
+ if (logger.isLoggable(Level.FINE)) {
+ logger.fine("tagging " + args[i].getName()
+ + " as (ARG_OBJ_ARRAY_STRUCT | ARG_WRITE | ARG_READ)");
+ }
+ }
+ }
+ } else if (type.isAssignableFrom(float.class)) {
+ args[i].setType(args[i].getType() | ARG_PRIMITIVE);
+ args[i].setType(args[i].getType() | ARG_FLOAT);
+ } else if (type.isAssignableFrom(int.class)) {
+ args[i].setType(args[i].getType() | ARG_PRIMITIVE);
+ args[i].setType(args[i].getType() | ARG_INT);
+ } else if (type.isAssignableFrom(double.class)) {
+ args[i].setType(args[i].getType() | ARG_PRIMITIVE);
+ args[i].setType(args[i].getType() | ARG_DOUBLE);
+ } else if (type.isAssignableFrom(long.class)) {
+ args[i].setType(args[i].getType() | ARG_PRIMITIVE);
+ args[i].setType(args[i].getType() | ARG_LONG);
+ } else if (type.isAssignableFrom(boolean.class)) {
+ args[i].setType(args[i].getType() | ARG_PRIMITIVE);
+ args[i].setType(args[i].getType() | ARG_BOOLEAN);
+ } else if (type.isAssignableFrom(byte.class)) {
+ args[i].setType(args[i].getType() | ARG_PRIMITIVE);
+ args[i].setType(args[i].getType() | ARG_BYTE);
+ } else if (type.isAssignableFrom(char.class)) {
+ args[i].setType(args[i].getType() | ARG_PRIMITIVE);
+ args[i].setType(args[i].getType() | ARG_CHAR);
+ } else if (type.isAssignableFrom(short.class)) {
+ args[i].setType(args[i].getType() | ARG_PRIMITIVE);
+ args[i].setType(args[i].getType() | ARG_SHORT);
+ }
+ // System.out.printf("in execute, arg %d %s %08x\n", i,args[i].name,args[i].type );
+ } catch (final IllegalArgumentException e) {
+ e.printStackTrace();
+ }
+
+ args[i].setPrimitiveSize(getPrimitiveSize(args[i].getType()));
+
+ if (logger.isLoggable(Level.FINE)) {
+ logger.fine("arg " + i + ", " + args[i].getName() + ", type=" + Integer.toHexString(args[i].getType())
+ + ", primitiveSize=" + args[i].getPrimitiveSize());
+ }
+
+ i++;
+ }
+
+ // at this point, i = the actual used number of arguments
+ // (private buffers do not get treated as arguments)
+
+ argc = i;
+
+ setArgsJNI(jniContextHandle, args, argc);
+ _settings.profile.onEvent(ProfilingEvent.PREPARE_EXECUTE);
+ try {
+ executeOpenCL(_settings);
+ isFallBack = false;
+ } catch (final AparapiException e) {
+ fallBackToNextDevice(_settings, e);
+ }
+ } else { // (entryPoint != null) && !entryPoint.shouldFallback()
+ fallBackToNextDevice(_settings, "failed to locate entrypoint");
+ }
+ } else { // (entryPoint == null) || (isFallBack)
+ try {
+ executeOpenCL(_settings);
+ isFallBack = false;
+ } catch (final AparapiException e) {
+ fallBackToNextDevice(_settings, e);
+ }
+ }
+ } else { // isOpenCL
+ if (!(device instanceof JavaDevice)) {
+ fallBackToNextDevice(_settings, "Non-OpenCL Kernel.EXECUTION_MODE requested but device is not a JavaDevice ");
+ }
+ executeJava(_settings, (JavaDevice) device);
+ }
+
+ if (Config.enableExecutionModeReporting) {
+ System.out.println("execution complete: " + kernel);
+ }
+
+ return kernel;
+ }
+ finally {
+ _settings.profile.onEvent(ProfilingEvent.EXECUTED);
+ maybeReportProfile(_settings);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "KernelRunner{" + kernel + "}";
+ }
+
+ private String describeDevice() {
+ Device device = KernelManager.instance().getPreferences(kernel).getPreferredDevice(kernel);
+ return (device == null) ? "<default fallback>" : device.getShortDescription();
+ }
+
+ private void maybeReportProfile(ExecutionSettings _settings) {
+ if (Config.dumpProfileOnExecution) {
+ StringBuilder report = new StringBuilder();
+ report.append(KernelDeviceProfile.getTableHeader()).append('\n');
+ report.append(_settings.profile.getLastDeviceProfile().getLastAsTableRow());
+ System.out.println(report);
+ }
+ }
+
+ @SuppressWarnings("deprecation")
+ private boolean isDeviceCompatible(Device device) {
+ Kernel.EXECUTION_MODE mode = kernel.getExecutionMode();
+ if (mode != Kernel.EXECUTION_MODE.AUTO) {
+ switch (device.getType()) {
+ case GPU:
+ return mode == Kernel.EXECUTION_MODE.GPU;
+ case CPU:
+ return mode == Kernel.EXECUTION_MODE.CPU;
+ case JTP:
+ return mode == Kernel.EXECUTION_MODE.JTP;
+ case SEQ:
+ return mode == Kernel.EXECUTION_MODE.SEQ;
+ case ACC:
+ return mode == Kernel.EXECUTION_MODE.ACC;
+ default:
+ return false;
+ }
+ } else {
+ return (device == kernel.getTargetDevice());
+ }
+ }
+
+ public int getCancelState() {
+ return inBufferRemoteInt.get(0);
+ }
+
+ public void cancelMultiPass() {
+ inBufferRemoteInt.put(0, CANCEL_STATUS_TRUE);
+ }
+
+ private void clearCancelMultiPass() {
+ inBufferRemoteInt.put(0, CANCEL_STATUS_FALSE);
+ }
+
+ /**
+ * Returns the index of the current pass, or one of two special constants with negative values to indicate special progress states. Those constants are
+ * {@link #PASS_ID_PREPARING_EXECUTION} to indicate that the Kernel has started executing but not reached the initial pass, or
+ * {@link #PASS_ID_COMPLETED_EXECUTION} to indicate that execution is complete (possibly due to early termination via {@link #cancelMultiPass()}), i.e. the Kernel
+ * is idle. {@link #PASS_ID_COMPLETED_EXECUTION} is also returned before the first execution has been invoked.
+ *
+ * <p>This can be used, for instance, to update a visual progress bar.
+ *
+ * @see #execute(String, Range, int)
+ */
+ public int getCurrentPass() {
+ if (!executing) {
+ return PASS_ID_COMPLETED_EXECUTION;
+ }
+
+ if (kernel.isRunningCL()) {
+ return getCurrentPassRemote();
+ } else {
+ return getCurrentPassLocal();
+ }
+ }
+
+ /**
+ * True while any of the {@code execute()} methods are in progress.
+ */
+ public boolean isExecuting() {
+ return executing;
+ }
+
+ protected int getCurrentPassRemote() {
+ return outBufferRemoteInt.get(0);
+ }
+
+ private int getCurrentPassLocal() {
+ return passId;
+ }
+
+ private int getPrimitiveSize(int type) {
+ if ((type & ARG_FLOAT) != 0) {
+ return 4;
+ } else if ((type & ARG_INT) != 0) {
+ return 4;
+ } else if ((type & ARG_BYTE) != 0) {
+ return 1;
+ } else if ((type & ARG_CHAR) != 0) {
+ return 2;
+ } else if ((type & ARG_BOOLEAN) != 0) {
+ return 1;
+ } else if ((type & ARG_SHORT) != 0) {
+ return 2;
+ } else if ((type & ARG_LONG) != 0) {
+ return 8;
+ } else if ((type & ARG_DOUBLE) != 0) {
+ return 8;
+ }
+ return 0;
+ }
+
+ private void setMultiArrayType(KernelArg arg, Class<?> type) throws AparapiException {
+ arg.setType(arg.getType() | (ARG_WRITE | ARG_READ | ARG_APARAPI_BUFFER));
+ int numDims = 0;
+ while (type.getName().startsWith("[[[[")) {
+ throw new AparapiException("Aparapi only supports 2D and 3D arrays.");
+ }
+ arg.setType(arg.getType() | ARG_ARRAYLENGTH);
+ while (type.getName().charAt(numDims) == '[') {
+ numDims++;
+ }
+ arg.setNumDims(numDims);
+ arg.setJavaBuffer(null); // will get updated in updateKernelArrayRefs
+ arg.setArray(null); // will get updated in updateKernelArrayRefs
+
+ Class<?> elementType = arg.getField().getType();
+ while (elementType.isArray()) {
+ elementType = elementType.getComponentType();
+ }
+
+ if (elementType.isAssignableFrom(float.class)) {
+ arg.setType(arg.getType() | ARG_FLOAT);
+ } else if (elementType.isAssignableFrom(int.class)) {
+ arg.setType(arg.getType() | ARG_INT);
+ } else if (elementType.isAssignableFrom(boolean.class)) {
+ arg.setType(arg.getType() | ARG_BOOLEAN);
+ } else if (elementType.isAssignableFrom(byte.class)) {
+ arg.setType(arg.getType() | ARG_BYTE);
+ } else if (elementType.isAssignableFrom(char.class)) {
+ arg.setType(arg.getType() | ARG_CHAR);
+ } else if (elementType.isAssignableFrom(double.class)) {
+ arg.setType(arg.getType() | ARG_DOUBLE);
+ } else if (elementType.isAssignableFrom(long.class)) {
+ arg.setType(arg.getType() | ARG_LONG);
+ } else if (elementType.isAssignableFrom(short.class)) {
+ arg.setType(arg.getType() | ARG_SHORT);
+ }
+ }
+
+ private final Set<Object> puts = new HashSet<Object>();
+
+ /**
+ * Enqueue a request to return this array from the GPU. This method blocks until the array is available.
+ * <br/>
+ * Note that <code>Kernel.put(type [])</code> calls will delegate to this call.
+ * <br/>
+ * Package public
+ *
+ * @param array
+ * It is assumed that this parameter is indeed an array (of int, float, short etc).
+ *
+ * @see Kernel#get(int[] arr)
+ * @see Kernel#get(float[] arr)
+ * @see Kernel#get(double[] arr)
+ * @see Kernel#get(long[] arr)
+ * @see Kernel#get(char[] arr)
+ * @see Kernel#get(boolean[] arr)
+ */
+ public void get(Object array) {
+ if (explicit && (kernel.isRunningCL())) {
+ // Only makes sense when we are using OpenCL
+ getJNI(jniContextHandle, array);
+ }
+ }
+
+ public List<ProfileInfo> getProfileInfo() {
+ if (explicit && (kernel.isRunningCL())) {
+ // Only makes sense when we are using OpenCL
+ return (getProfileInfoJNI(jniContextHandle));
+ } else {
+ return (null);
+ }
+ }
+
+ /**
+ * Tag this array so that it is explicitly enqueued before the kernel is executed. <br/>
+ * Note that <code>Kernel.put(type [])</code> calls will delegate to this call. <br/>
+ * Package public
+ *
+ * @param array
+ * It is assumed that this parameter is indeed an array (of int, float, short etc).
+ * @see Kernel#put(int[] arr)
+ * @see Kernel#put(float[] arr)
+ * @see Kernel#put(double[] arr)
+ * @see Kernel#put(long[] arr)
+ * @see Kernel#put(char[] arr)
+ * @see Kernel#put(boolean[] arr)
+ */
+
+ public void put(Object array) {
+ if (explicit && (kernel.isRunningCL())) {
+ // Only makes sense when we are using OpenCL
+ puts.add(array);
+ }
+ }
+
+ private boolean explicit = false;
+
+ public void setExplicit(boolean _explicit) {
+ explicit = _explicit;
+ }
+
+ public boolean isExplicit() {
+ return (explicit);
+ }
+
+ private static class ExecutionSettings {
+ final KernelPreferences preferences;
+ final KernelProfile profile;
+ final String entrypoint;
+ Range range;
+ final int passes;
+ final boolean legacyExecutionMode;
+
+ private ExecutionSettings(KernelPreferences preferences, KernelProfile profile, String entrypoint, Range range, int passes, boolean legacyExecutionMode) {
+ this.preferences = preferences;
+ this.profile = profile;
+ this.entrypoint = entrypoint;
+ this.range = range;
+ this.passes = passes;
+ this.legacyExecutionMode = legacyExecutionMode;
+ }
+
+ @Override
+ public String toString() {
+ return "ExecutionSettings{" +
+ "preferences=" + preferences +
+ ", profile=" + profile +
+ ", entrypoint='" + entrypoint + '\'' +
+ ", range=" + range +
+ ", passes=" + passes +
+ ", legacyExecutionMode=" + legacyExecutionMode +
+ '}';
+ }
+ }
+}