No commit message

No commit message

test/runtime/src/java/com/amd/aparapi/test/runtime/BufferTransfer.java

 package com.amd.aparapi.test.runtime;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
 
-import java.io.File;
-import java.io.IOException;
 import java.util.Arrays;
 
 import org.junit.After;
@@ -26,7 +24,7 @@ public class BufferTransfer{
    interface Comparer{
       boolean same(int[] lhs, int[] rhs, int index);
    }
-   
+
    interface Operator{
       void apply(int[] lhs, int[] rhs, int index);
    }
@@ -36,8 +34,7 @@ public class BufferTransfer{
          _filler.fill(array, i);
       }
    }
-   
-  
+
    boolean same(int[] lhs, int[] rhs, Comparer _comparer) {
       boolean same = lhs != null && rhs != null && lhs.length == rhs.length;
       for (int i = 0; same && i < lhs.length; i++) {
@@ -63,52 +60,29 @@ public class BufferTransfer{
    void apply(int[] lhs, int[] rhs, Operator _operator) {
       for (int i = 0; i < lhs.length; i++) {
          _operator.apply(lhs, rhs, i);
-      } 
-   }
-
-   public static class BufferTransferKernel extends Kernel{
-      int[] inSmall;
-
-      int[] inLarge;
-
-      int[] inOutSmall;
-
-      int[] inOutLarge;
-
-      int[] outSmall;
-
-      int[] outLarge;
-
-      int pass;
-
-      @Override public void run() {
-         int gid = getGlobalId(0);
-         outSmall[gid] = inSmall[gid];
-         outLarge[gid * 1024 * 16 + pass] = inSmall[gid];
-
       }
-
    }
 
+  
+
    static OpenCLDevice openCLDevice = null;
+
    @BeforeClass public static void setUpBeforeClass() throws Exception {
       //System.out.println("setUpBeforeClass");
       Device device = Device.best();
-      if (device == null || !(device instanceof OpenCLDevice)){
+      if (device == null || !(device instanceof OpenCLDevice)) {
          throw new IllegalStateException("no opencl device!");
       }
-      openCLDevice = (OpenCLDevice)device;
+      openCLDevice = (OpenCLDevice) device;
    }
 
    @AfterClass public static void tearDownAfterClass() throws Exception {
       //System.out.println("tearDownAfterClass");
    }
-   
- 
 
    @Before public void setUp() throws Exception {
       //System.out.println("setup");
-     
+
    }
 
    @After public void tearDown() throws Exception {
@@ -134,10 +108,10 @@ public class BufferTransfer{
       final int SIZE = 1024;
       final InOutKernel kernel = new InOutKernel();
       final Range range = openCLDevice.createRange(SIZE);
-     
+
       kernel.in = new int[SIZE];
       kernel.out = new int[SIZE];
-     
+
       fill(kernel.in, new Filler(){
          public void fill(int[] array, int index) {
             array[index] = index;
@@ -148,7 +122,7 @@ public class BufferTransfer{
       assertTrue("in == out", same(kernel.in, kernel.out));
 
    }
-   
+
    public static class AddKernel extends Kernel{
 
       int[] values;
@@ -157,18 +131,18 @@ public class BufferTransfer{
 
       @Override public void run() {
          int gid = getGlobalId(0);
-         result[gid] = result[gid]+values[gid];
+         result[gid] = result[gid] + values[gid];
 
       }
 
    }
 
-   @Test public void addOnce() {
+   @Test public void auto() {
 
       final int SIZE = 1024;
       final AddKernel kernel = new AddKernel();
       final Range range = openCLDevice.createRange(SIZE);
-     
+
       kernel.values = new int[SIZE];
       kernel.result = new int[SIZE];
       zero(kernel.result);
@@ -177,44 +151,44 @@ public class BufferTransfer{
             array[index] = index;
          }
       });
-      
+
       int[] expectedResult = Arrays.copyOf(kernel.result, kernel.result.length);
-      
+
       apply(expectedResult, kernel.values, new Operator(){
 
          @Override public void apply(int[] lhs, int[] rhs, int index) {
-             lhs[index] = lhs[index]+rhs[index];
-            
-         }});
+            lhs[index] = lhs[index] + rhs[index];
+
+         }
+      });
       kernel.execute(range);
 
       assertTrue("expectedResult == result", same(expectedResult, kernel.result));
-      
+
       kernel.execute(range);
-      
+
       apply(expectedResult, kernel.values, new Operator(){
 
          @Override public void apply(int[] lhs, int[] rhs, int index) {
-             lhs[index] = lhs[index]+rhs[index];
-            
-         }});
+            lhs[index] = lhs[index] + rhs[index];
+
+         }
+      });
       assertTrue("expectedResult == result", same(expectedResult, kernel.result));
-      
-      
+
       zero(kernel.values);
       kernel.execute(range);
       assertTrue("expectedResult == result", same(expectedResult, kernel.result));
-      
 
    }
-   
-   @Test public void addExplicit() {
+
+   @Test public void explicit() {
 
       final int SIZE = 1024;
       final AddKernel kernel = new AddKernel();
       kernel.setExplicit(true);
       final Range range = openCLDevice.createRange(SIZE);
-     
+
       kernel.values = new int[SIZE];
       kernel.result = new int[SIZE];
       zero(kernel.result);
@@ -223,46 +197,89 @@ public class BufferTransfer{
             array[index] = index;
          }
       });
-      
+
       int[] expectedResult = Arrays.copyOf(kernel.result, kernel.result.length);
-      
+
       apply(expectedResult, kernel.values, new Operator(){
 
          @Override public void apply(int[] lhs, int[] rhs, int index) {
-             lhs[index] = lhs[index]+rhs[index];
-            
-         }});
-      
+            lhs[index] = lhs[index] + rhs[index];
+
+         }
+      });
+
       kernel.execute(range).get(kernel.result);
 
       assertTrue("after first explicit add expectedResult == result", same(expectedResult, kernel.result));
-      
+
       kernel.execute(range).get(kernel.result);
-      
+
       apply(expectedResult, kernel.values, new Operator(){
          @Override public void apply(int[] lhs, int[] rhs, int index) {
-             lhs[index] = lhs[index]+rhs[index];
-            
-         }});
+            lhs[index] = lhs[index] + rhs[index];
+
+         }
+      });
       assertTrue("after second explicit add expectedResult == result", same(expectedResult, kernel.result));
-      
-      
+
       zero(kernel.values);
-      
+
       kernel.put(kernel.values).execute(range).get(kernel.result);
-      
+
       assertTrue("after zeroing values and third explici add expectedResult == result", same(expectedResult, kernel.result));
-      
-      
+
       zero(kernel.result);
-      
+
       kernel.put(kernel.result).execute(range).get(kernel.result);
-      
-      
+
       zero(expectedResult);
+
+      assertTrue("after zeroing values and result and forth  explicit add expectedResult == result",
+            same(expectedResult, kernel.result));
+
+   }
+
+   private class TestKernel extends Kernel{
+      int[] simStep = new int[1];
+
+      int[] neuronOutputs = new int[3];
       
-      assertTrue("after zeroing values and result and forth  explicit add expectedResult == result", same(expectedResult, kernel.result));
+      int[] expected = new int []{3, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0};
+
+      public void step() {
+         int simSteps = 16;
+         int[][] log = new int[neuronOutputs.length][simSteps];
+         put(neuronOutputs);
+         for (simStep[0] = 0; simStep[0] < simSteps; simStep[0]++) {
+            put(simStep).execute(neuronOutputs.length).get(neuronOutputs);
+            for (int n = 0; n < neuronOutputs.length; n++)
+               log[n][simStep[0]] = neuronOutputs[n];
+         }
+         System.out.println(getExecutionMode() + (isExplicit() ? ", explicit" : ", auto"));
+     
+         for (int n = 0; n < neuronOutputs.length; n++)
+            System.out.println(Arrays.toString(log[n]));
       
+         assertTrue("log[2] == expected", same(log[2], expected));
+      }
+
+      @Override public void run() {
+         int neuronID = getGlobalId();
+         neuronOutputs[neuronID] = (simStep[0] % (neuronID + 2) == 0) ? (neuronID + 1) : 0;
+      }
+   }
+
+   @Test public void issue60Explicit() {
+
+      TestKernel kernel = new TestKernel();
+      kernel.setExplicit(true);
+      kernel.step();
+
+   }
+   
+   @Test public void issue60Auto() {
+      TestKernel kernel = new TestKernel();
+      kernel.step();
 
    }