diff --git a/documentation/BuildingNBody.html b/documentation/BuildingNBody.html
index eb87058244551d84265112a064a6ecf4c5e62583..f45b85c552bc5aa87d9037a5aa0dcc8adfa3da18 100644
--- a/documentation/BuildingNBody.html
+++ b/documentation/BuildingNBody.html
@@ -66,7 +66,7 @@
examples/
...
nbody/
- src/java/com.amd.aparapi.nbody/
+ src/java/com.syncleus.aparapi.nbody/
build.xml
nbody.sh
nbody.bat
diff --git a/documentation/ConvertingBytecodeToOpenCL.html b/documentation/ConvertingBytecodeToOpenCL.html
index 071b693a921379576e442f3c3f0b581a384137c1..de5fde973743300c07a43a4fac06887bcead7f03 100644
--- a/documentation/ConvertingBytecodeToOpenCL.html
+++ b/documentation/ConvertingBytecodeToOpenCL.html
@@ -74,7 +74,7 @@
<p>The classfile format is well documented here and we will not go into too much detail here, however it should be known that Aparapi must parse the classfile of each Kernel to extract the bytecode for the Kernel.run() and any method reachable from Kernel.run().</p>
<p>Lets start with a simple Kernel.</p>
- <pre class="highlight plaintext"><code>import com.amd.aparapi.Kernel;
+ <pre class="highlight plaintext"><code>import com.syncleus.aparapi.Kernel;
public class Squarer extends Kernel{
int[] in;
@@ -92,7 +92,7 @@
<pre class="highlight plaintext"><code>javap -c -classpath path/to/aparapi/aparapi.jar;. Squarer
</code></pre>
<p>Compiled from “Squarer.java”</p>
- <pre class="highlight plaintext"><code>public class Squarer extends com.amd.aparapi.Kernel
+ <pre class="highlight plaintext"><code>public class Squarer extends com.syncleus.aparapi.Kernel
SourceFile: "Squarer.java"
minor version: 0
major version: 50
diff --git a/documentation/DevelopersGuideLinux.html b/documentation/DevelopersGuideLinux.html
index c4adb19f116e507240d1d1077eaede55d66250f4..8bb89fe2f8d1026b36b03cdcaf6382dff7d17f45 100644
--- a/documentation/DevelopersGuideLinux.html
+++ b/documentation/DevelopersGuideLinux.html
@@ -134,7 +134,7 @@
<h2>Eclipse</h2>
- <p>Eclipse is not required to build Aparapi; however, the developers of Aparapi do use Eclipse and have made the Eclipse artifacts (.classpath and .project files) available so that projects can be imported into Eclipse. The com.amd.aparapi.jni subproject (containing C++ JNI source) should be imported as a resource project. We do not recommend importing com.amd.aparapi.jni as a CDT project, and we do not recommend trying to configure a CDT build, the existing build.xml files has been customized for multiplatform C++ compilations.</p>
+ <p>Eclipse is not required to build Aparapi; however, the developers of Aparapi do use Eclipse and have made the Eclipse artifacts (.classpath and .project files) available so that projects can be imported into Eclipse. The com.syncleus.aparapi.jni subproject (containing C++ JNI source) should be imported as a resource project. We do not recommend importing com.syncleus.aparapi.jni as a CDT project, and we do not recommend trying to configure a CDT build, the existing build.xml files has been customized for multiplatform C++ compilations.</p>
<h2>Building</h2>
@@ -143,43 +143,43 @@
</code></pre>
<p>Checkout provides the following:</p>
<pre class="highlight plaintext"><code>aparapi/
- com.amd.aparapi/
- src/java/com.amd.aparapi/*.java
+ com.syncleus.aparapi/
+ src/java/com.syncleus.aparapi/*.java
build.xml
- com.amd.aparapi.jni/
+ com.syncleus.aparapi.jni/
src/cpp/*.cpp
src/cpp/*.h
build.xml
test/
codegen/
src/java/
- com.amd.aparapi/
- com.amd.aparapi.test/
+ com.syncleus.aparapi/
+ com.syncleus.aparapi.test/
build.xml
runtime/
src/java/
- com.amd.aparapi/
- com.amd.aparapi.test/
+ com.syncleus.aparapi/
+ com.syncleus.aparapi.test/
build.xml
samples/
mandel
- src/java/com.amd.aparapi.samples.mandel/*.java
+ src/java/com.syncleus.aparapi.samples.mandel/*.java
build.xml
mandel.sh
mandel.bat
squares/
- src/java/com.amd.aparapi.samples.squares/*.java
+ src/java/com.syncleus.aparapi.samples.squares/*.java
build.xml
squares.sh
squares.bat
convolution/
- src/java/com.amd.aparapi.samples.convolution/*.java
+ src/java/com.syncleus.aparapi.samples.convolution/*.java
build.xml
conv.sh
conv.bat
examples/
nbody/
- src/java/com.amd.aparapi.nbody/
+ src/java/com.syncleus.aparapi.nbody/
build.xml
nbody.sh
nbody.bat
@@ -190,15 +190,15 @@
</code></pre>
<h2>Sub Directories</h2>
- <p>The com.amd.aparapi and com.amd.aparapi.jni subdirectories contain the source for building and using Aparapi.</p>
+ <p>The com.syncleus.aparapi and com.syncleus.aparapi.jni subdirectories contain the source for building and using Aparapi.</p>
<p>The ant build.xml file, in each folder accept common ‘clean’ and 'build’ targets. You can use the build.xml file at the root of the tree for two purposes:</p>
- <pre class="highlight plaintext"><code>To initiate a build com.amd.aparapi of com.amd.aparapi.jni.
+ <pre class="highlight plaintext"><code>To initiate a build com.syncleus.aparapi of com.syncleus.aparapi.jni.
To create a binary ‘distribution’ directory and zip file. This zip file is same as those available from the download section of the code.google.com/p/aparapi site.
</code></pre>
<h2>Preparing for your first build</h2>
- <p>Edit com.amd.aparapi.jni\build.properties and ensure that the properties are valid for your platform.</p>
+ <p>Edit com.syncleus.aparapi.jni\build.properties and ensure that the properties are valid for your platform.</p>
<p>View the comments in the properties file for assistance. The build.xml ant file contains some simple checks to help diagnose simple configuration errors in case something gets messed up.</p>
diff --git a/documentation/DevelopersGuideWindows.html b/documentation/DevelopersGuideWindows.html
index 3f80491b6544252a08ecb8cc7beea57bbd746627..753a6e5880b1ad7cdc729308196cb161cdfd61d6 100644
--- a/documentation/DevelopersGuideWindows.html
+++ b/documentation/DevelopersGuideWindows.html
@@ -113,7 +113,7 @@
<h2>A C++ compiler</h2>
- <p>For Microsoft® Windows® platforms the JNI build can support either Microsoft® Visual Studio® 2008, 2009 or 2010 compiler or MinGW (Minimal GNU for Windows) from GNU. Now that Visual Studio express is available for free, we would recommend using Visual studio. If you wish to use another compiler then you will have to tweak the com.amd.aparapi.jni/build.xml file to get your compiler to work.
+ <p>For Microsoft® Windows® platforms the JNI build can support either Microsoft® Visual Studio® 2008, 2009 or 2010 compiler or MinGW (Minimal GNU for Windows) from GNU. Now that Visual Studio express is available for free, we would recommend using Visual studio. If you wish to use another compiler then you will have to tweak the com.syncleus.aparapi.jni/build.xml file to get your compiler to work.
Microsoft® Visual Studio® 2008/2010 for 32-bit or 64-bit platforms</p>
<p>Aparapi has been tested with various versions of Microsoft® Visual Studio® 2008, 2009 and 2010 including Enterprise, Professional and Express editions, if you encounter any version specific issues please let us know so we can address it and/or update this documentation.</p>
@@ -122,7 +122,7 @@
<p>And an SDK, such as. c:\Program Files\Microsoft SDKs\Windows\v6.0A</p>
- <p>Note the location of both of these as this information will be needed to configure the com.amd.aparapi.jni\build.property file (later).
+ <p>Note the location of both of these as this information will be needed to configure the com.syncleus.aparapi.jni\build.property file (later).
For Visual Studio Express 64 bit users</p>
<p>Visual studio express does not include the 64 bit compiler or libraries. You will need to also install the SDK from Microsoft. this link should help</p>
@@ -153,7 +153,7 @@
<p>Eclipse is not required to build Aparapi, however the developers of Aparapi do use Eclipse and have made the Eclipse artifacts (.classpath and .project files) available so that projects can be imported into Eclipse.</p>
- <p>The com.amd.aparapi.jni subproject (containing C++ JNI source) should be imported as a resource project, we do not recommend importing com.amd.aparapi.jni as a CDT project, and we do not recommend trying to configure a CDT build, the existing build.xml files has been customized for multiplatform C++ compilations.</p>
+ <p>The com.syncleus.aparapi.jni subproject (containing C++ JNI source) should be imported as a resource project, we do not recommend importing com.syncleus.aparapi.jni as a CDT project, and we do not recommend trying to configure a CDT build, the existing build.xml files has been customized for multiplatform C++ compilations.</p>
<h2>Building</h2>
@@ -163,43 +163,43 @@
<p>You will end up with the following files/directories</p>
<pre class="highlight plaintext"><code>aparapi/
- com.amd.aparapi/
- src/java/com.amd.aparapi/*.java
+ com.syncleus.aparapi/
+ src/java/com.syncleus.aparapi/*.java
build.xml
- com.amd.aparapi.jni/
+ com.syncleus.aparapi.jni/
src/cpp/*.cpp
src/cpp/*.h
build.xml
test/
codegen/
src/java/
- com.amd.aparapi/
- com.amd.aparapi.test/
+ com.syncleus.aparapi/
+ com.syncleus.aparapi.test/
build.xml
runtime/
src/java/
- com.amd.aparapi/
- com.amd.aparapi.test/
+ com.syncleus.aparapi/
+ com.syncleus.aparapi.test/
build.xml
samples/
mandel
- src/java/com.amd.aparapi.samples.mandel/*.java
+ src/java/com.syncleus.aparapi.samples.mandel/*.java
build.xml
mandel.sh
mandel.bat
squares/
- src/java/com.amd.aparapi.samples.squares/*.java
+ src/java/com.syncleus.aparapi.samples.squares/*.java
build.xml
squares.sh
squares.bat
convolution/
- src/java/com.amd.aparapi.samples.convolution/*.java
+ src/java/com.syncleus.aparapi.samples.convolution/*.java
build.xml
conv.sh
conv.bat
examples/
nbody/
- src/java/com.amd.aparapi.nbody/
+ src/java/com.syncleus.aparapi.nbody/
build.xml
nbody.sh
nbody.bat
@@ -210,17 +210,17 @@
</code></pre>
<h2>Sub Directories</h2>
- <p>The com.amd.aparapi and com.amd.aparapi.jni subdirectories contain the source for building and using Aparapi.</p>
+ <p>The com.syncleus.aparapi and com.syncleus.aparapi.jni subdirectories contain the source for building and using Aparapi.</p>
<p>The ant build.xml file, in each folder accept ‘clean’ and 'build’ targets.</p>
<p>Use the build.xml file at the root of the tree for two purposes:</p>
- <pre class="highlight plaintext"><code>To initiate a build of com.amd.aparapi and com.amd.aparapi.jni.
+ <pre class="highlight plaintext"><code>To initiate a build of com.syncleus.aparapi and com.syncleus.aparapi.jni.
To create a binary distribution directory and zip file. This zip file is same as those available from the download section of the code.google.com/p/aparapi site.
</code></pre>
<h2>Preparing for your first build</h2>
- <p>You should only need to edit com.amd.aparapi.jni\build.xml file if you wish to use mingw or if you Visual Studio or gcc compiler is in an unusual place.</p>
+ <p>You should only need to edit com.syncleus.aparapi.jni\build.xml file if you wish to use mingw or if you Visual Studio or gcc compiler is in an unusual place.</p>
<p>Perform a build from the root directory using the following command:</p>
<pre class="highlight plaintext"><code>$ ant clean dist
diff --git a/documentation/FrequentlyAskedQuestions.html b/documentation/FrequentlyAskedQuestions.html
index 04e12a3b224a287bf60bea87898a60ad872da134..225961ef94663900c3a5109a10753f04723aee7d 100644
--- a/documentation/FrequentlyAskedQuestions.html
+++ b/documentation/FrequentlyAskedQuestions.html
@@ -105,7 +105,7 @@
<h2>Is there a way I can see the generated OpenCL?</h2>
- <p>Yes, by using adding -Dcom.amd.aparapi.enableShowGeneratedOpenCL=true to your command line when you start your JVM.</p>
+ <p>Yes, by using adding -Dcom.syncleus.aparapi.enableShowGeneratedOpenCL=true to your command line when you start your JVM.</p>
<h2>Does Aparapi support sharing buffers with JOGL? Can I exploit the features of JOGAMP/glugen?</h2>
@@ -149,7 +149,7 @@
</code></pre>
<p>The above code fragment will print either ‘GPU’ if the kernel executed on the GPU or JTP if Aparapi executed the Kernel in a Java Thread Pool.</p>
- <p>Alternatively, setting the property –Dcom.amd.aparapi.enableShowExecutionModes=true when you start your JVM will cause Aparapi to automatically report the execution mode of all kernels to stdout.</p>
+ <p>Alternatively, setting the property –Dcom.syncleus.aparapi.enableShowExecutionModes=true when you start your JVM will cause Aparapi to automatically report the execution mode of all kernels to stdout.</p>
<h2>Why does Aparapi need me to compile my code with -g?</h2>
diff --git a/documentation/PrivateMemorySpace.html b/documentation/PrivateMemorySpace.html
index f0f3dcfca97e6081b51bdce7596ff8f126a991e4..c1dd8d2d043777ac32f96737a56da6f07aae82c1 100644
--- a/documentation/PrivateMemorySpace.html
+++ b/documentation/PrivateMemorySpace.html
@@ -86,7 +86,7 @@
<p>The Kernel.NoCL annotation exists to allow specialised code to be executed when running in Java (or JTP) which is not invoked when running on the GPU. A NoCL method can be inserted at the begining of a Kernel’s run() method which sets the private array to a value obtained from a static ThreadLocal<foo[]> where foo is the primitive type of the array in question. This will have no effect upon OpenCL execution, but will allow threadsafe execution when running in java.</p>
- <p>In the project samples, there is a package com.amd.aparapi.sample.median which gives an example of a median image filter which uses a private array of pixel data to apply a distructive median algorithm to a “window” of local pixels. This sample also demonstrates how to use the ThreadLocal trick to allow correct behaviour when running in JTP execution mode.</p>
+ <p>In the project samples, there is a package com.syncleus.aparapi.sample.median which gives an example of a median image filter which uses a private array of pixel data to apply a distructive median algorithm to a “window” of local pixels. This sample also demonstrates how to use the ThreadLocal trick to allow correct behaviour when running in JTP execution mode.</p>
<p><a href="http://code.google.com/p/aparapi/source/browse/trunk/samples/median/src/com/amd/aparapi/sample/median/MedianDemo.java" rel="nofollow">http://code.google.com/p/aparapi/source/browse/trunk/samples/median/src/com/amd/aparapi/sample/median/MedianDemo.java</a></p>
</div>
diff --git a/documentation/ProfilingKernelExecution.html b/documentation/ProfilingKernelExecution.html
index 75825be8b9baf2903f35ea691a7b9936728371f3..e67cad94ee666f5f063d743f60329765305e6238 100644
--- a/documentation/ProfilingKernelExecution.html
+++ b/documentation/ProfilingKernelExecution.html
@@ -59,7 +59,7 @@
<p><em>Using Aparapi’s built in profiling APIs Updated May 7, 2013 by frost.g…@gmail.com</em></p>
<p>If you want to extract OpenCL performance info from a kernel at runtime you need to set the property :-</p>
- <pre class="highlight plaintext"><code>-Dcom.amd.aparapi.enableProfiling=true
+ <pre class="highlight plaintext"><code>-Dcom.syncleus.aparapi.enableProfiling=true
</code></pre>
<p>Your application can then call kernel.getProfileInfo() after a successful call to kernel.execute(range) to extract a List List<ProfileInfo>.</p>
@@ -96,7 +96,7 @@
<p>And here is the tabular output from</p>
<pre class="highlight plaintext"><code> java
-Djava.library.path=${APARAPI_HOME}
- -Dcom.amd.aparapi.enableProfiling=true
+ -Dcom.syncleus.aparapi.enableProfiling=true
-cp ${APARAPI_HOME}:.
MyClass
diff --git a/documentation/UnitTestGuide.html b/documentation/UnitTestGuide.html
index 06fd36d339e74fbf524fd1092ec04ce7d5ab7756..c6354c109273ebedc665c65b634d610ab5d404c4 100644
--- a/documentation/UnitTestGuide.html
+++ b/documentation/UnitTestGuide.html
@@ -65,14 +65,14 @@
<p>The initial open source tree includes the codegen subdirectory (test/codegen), which used to validate the Aparapi bytecode to OpenCLâ„¢ conversion.</p>
<pre class="highlight plaintext"><code>aparapi/trunk/
- com.amd.aparapi/
- src/java/com.amd.aparapi/
+ com.syncleus.aparapi/
+ src/java/com.syncleus.aparapi/
build.xml
test/
codegen/
src/java/
- com.amd.aparapi/
- com.amd.aparapi.test/
+ com.syncleus.aparapi/
+ com.syncleus.aparapi.test/
build.xml
build.xml
</code></pre>
@@ -80,7 +80,7 @@
<h2>Running the OpenCLâ„¢ code generation JUnit tests</h2>
- <p>Before executing the code generation tests, build the com.amd.aparapi sub-project and ensure that you have JUnit 4 installed.</p>
+ <p>Before executing the code generation tests, build the com.syncleus.aparapi sub-project and ensure that you have JUnit 4 installed.</p>
<p>Edit the junit.jar property in test/codegen/build.xml to point to your install directory.</p>
<pre class="highlight plaintext"><code><property name="junit.jar" value="C:\JUnit4.9\junit-4.9.jar"/>
@@ -101,12 +101,12 @@
<p>The test cases for OpenCLâ„¢ code generation are not strictly JUnit tests. Instead the codegen Java tree contains a tool (CreateJUnitTests) to create JUnit test cases from specially formatted test source files.</p>
- <p>The package <code>com.amd.aparapi.test (codegen/src/java/com/amd/aparapi/test)</code> contains all of the existing code generation tests.</p>
+ <p>The package <code>com.syncleus.aparapi.test (codegen/src/java/com/amd/aparapi/test)</code> contains all of the existing code generation tests.</p>
- <p>Here is an example that tests the code generation resulting from a call to Kernel.getPassId(), this is taken from com.amd.aparapi.test.CallGetPassId</p>
- <pre class="highlight plaintext"><code>package com.amd.aparapi.test;
+ <p>Here is an example that tests the code generation resulting from a call to Kernel.getPassId(), this is taken from com.syncleus.aparapi.test.CallGetPassId</p>
+ <pre class="highlight plaintext"><code>package com.syncleus.aparapi.test;
- import com.amd.aparapi.Kernel;
+ import com.syncleus.aparapi.Kernel;
public class CallGetPassId extends Kernel{
public void run() {
@@ -142,7 +142,7 @@
<ul>
<li>compiles the src/java tree. This compiles all the test cases as well as a few ‘utility’ classes.</li>
- <li>executes the com.amd.aparapi.test.CreateJUnitTests program. This iterates through all of the test source files and converts them to JUnit form. The generated source is written to the src/genjava tree.</li>
+ <li>executes the com.syncleus.aparapi.test.CreateJUnitTests program. This iterates through all of the test source files and converts them to JUnit form. The generated source is written to the src/genjava tree.</li>
<li>compiles the src/genjava tree to create the required JUnit classes</li>
<li>initiates the JUnit test phase (result data in junit/data)</li>
<li>creates the JUnit report (in junit/html/junit from junit/data)</li>
@@ -171,7 +171,7 @@
<p>Logically either of the above are correct. However, to accommodate the alternate acceptable forms we need to add two complete <code>/**{OpenCL{ and }OpenCL}**/</code> sections to the file. If either matches, the test will pass.</p>
<p>Here is the complete BooleanToggle code.</p>
- <pre class="highlight plaintext"><code>package com.amd.aparapi.test;
+ <pre class="highlight plaintext"><code>package com.syncleus.aparapi.test;
public class BooleanToggle{
public void run() {
diff --git a/documentation/UsersGuide.html b/documentation/UsersGuide.html
index 68333c7309652cf587d85142ea27841ce58a12ea..af932f6a37339a25a2bfc9fa5e7630ab20e53a4a 100644
--- a/documentation/UsersGuide.html
+++ b/documentation/UsersGuide.html
@@ -109,7 +109,7 @@
thread.start();
thread.join();
</code></pre>
- <p>The Aparapi developer extends the com.amd.aparapi.Kernel and overrides the public void Kernel.run() method. It is this Kernel.run() method that is executed in parallel.</p>
+ <p>The Aparapi developer extends the com.syncleus.aparapi.Kernel and overrides the public void Kernel.run() method. It is this Kernel.run() method that is executed in parallel.</p>
<p>The base class also exposes the Kernel.execute(range) method which is used to initiate the execution of Kernel.run() over the range 0…n.</p>
@@ -149,8 +149,8 @@
System.out.println(“Kernel nid not execute on the GPU!â€);
}
</code></pre>
- <p>To obtain a runtime report of the execution mode of all kernel executions, set the com.amd.aparapi.enableExecutionModeReporting property to true when the JVM is launched.</p>
- <pre class="highlight plaintext"><code>$ java –Djava.library.path=${APARAPI_DIR} –Dcom.amd.aparapi.enableExecutionModeReporting=true –cp ${APARAPI_DIR}/aparapi.jar;. Squares
+ <p>To obtain a runtime report of the execution mode of all kernel executions, set the com.syncleus.aparapi.enableExecutionModeReporting property to true when the JVM is launched.</p>
+ <pre class="highlight plaintext"><code>$ java –Djava.library.path=${APARAPI_DIR} –Dcom.syncleus.aparapi.enableExecutionModeReporting=true –cp ${APARAPI_DIR}/aparapi.jar;. Squares
</code></pre>
<h2>Running the sample applications</h2>
@@ -165,7 +165,7 @@
<p>Set the environment variable JAVA_HOME to point to the root of your JRE or JDK.
Change to the appropriate samples directory (samples/squares or samples/mandel)
Run either the .bat or .sh script. On Linux® , you might have to initially chmod +x script.sh to add execute permissions.
- The sample scripts pass the first arg (%1 or $1) to -Dcom.amd.aparapi.executionMode when the JVM is launched. This allows the sample to be tested in either GPU or JTP execution modes by passing the requested mode.</p>
+ The sample scripts pass the first arg (%1 or $1) to -Dcom.syncleus.aparapi.executionMode when the JVM is launched. This allows the sample to be tested in either GPU or JTP execution modes by passing the requested mode.</p>
<pre class="highlight plaintext"><code>$ cd samples/mandel
$ bash ./mandel.sh GPU
<executes in GPU mode here>
diff --git a/documentation/UsingAparapiLambdaBranchWithHSASimulator.html b/documentation/UsingAparapiLambdaBranchWithHSASimulator.html
index fa6ab59531ca091b72634dae7575999d024acc90..21c511b44566b190667fdd0ebf4d729f58a53eed 100644
--- a/documentation/UsingAparapiLambdaBranchWithHSASimulator.html
+++ b/documentation/UsingAparapiLambdaBranchWithHSASimulator.html
@@ -98,7 +98,7 @@
$ cd /home/gfrost/aparapi/branches/lambda
$ ant
$ export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:${OKRA}/dist/bin
- $ java -agentpath:com.amd.aparapi.jni/dist/libaparapi_x86_64.so -cp com.amd.aparapi/dist/aparapi.jar:${OKRA}/dist/okra.jar hsailtest.Squares
+ $ java -agentpath:com.syncleus.aparapi.jni/dist/libaparapi_x86_64.so -cp com.syncleus.aparapi/dist/aparapi.jar:${OKRA}/dist/okra.jar hsailtest.Squares
$
</code></pre>
</div>
diff --git a/documentation/UsingConstantMemory.html b/documentation/UsingConstantMemory.html
index aa22372d265c2b7a969dba54dcc22bae2de3ea6b..e6a795f32c3d38eaa02296a609a468a5554ca2b3 100644
--- a/documentation/UsingConstantMemory.html
+++ b/documentation/UsingConstantMemory.html
@@ -60,7 +60,7 @@
<h2>How to make use of new constant memory feature</h2>
- <p>By default all primitive arrays accessed by an Aparapi Kernel is considered global. If we look at the generated code using <code>-Dcom.amd.aparapi.enableShowGeneratedOpenCL=true</code> we will see that primitive arrays (such as <code>int buf[]</code>) are mapped to <code>__global</code> pointers (such as <code>__global int *buf</code>) in OpenCL.</p>
+ <p>By default all primitive arrays accessed by an Aparapi Kernel is considered global. If we look at the generated code using <code>-Dcom.syncleus.aparapi.enableShowGeneratedOpenCL=true</code> we will see that primitive arrays (such as <code>int buf[]</code>) are mapped to <code>__global</code> pointers (such as <code>__global int *buf</code>) in OpenCL.</p>
<p>Although this makes Aparapi easy to use (especially to Java developers who are unfamiliar to tiered memory hierarchies), it does limit the ability of the ‘power developer’ wanting to extract more performance from Aparapi on the GPU.</p>
diff --git a/documentation/UsingLocalMemory.html b/documentation/UsingLocalMemory.html
index 154afe2ce630fcace9fc07247824e6c047e80376..109e88ec3a15153cc26dff387ba8e702bfe541ed 100644
--- a/documentation/UsingLocalMemory.html
+++ b/documentation/UsingLocalMemory.html
@@ -60,7 +60,7 @@
<h2>How to make use of new local memory feature</h2>
- <p>By default all primitive arrays accessed by an Aparapi Kernel is considered global. If we look at the generated code using -Dcom.amd.aparapi.enableShowGeneratedOpenCL=true we will see that primitive arrays (such as int buf[]) are mapped to _<em>global pointers (such as _</em>global int *buf) in OpenCL.</p>
+ <p>By default all primitive arrays accessed by an Aparapi Kernel is considered global. If we look at the generated code using -Dcom.syncleus.aparapi.enableShowGeneratedOpenCL=true we will see that primitive arrays (such as int buf[]) are mapped to _<em>global pointers (such as _</em>global int *buf) in OpenCL.</p>
<p>Although this makes Aparapi easy to use (especially to Java developers who are unfamiliar to tiered memory hierarchies), it does limit the ability of the ‘power developer’ wanting to extract more performance from Aparapi on the GPU.</p>
diff --git a/documentation/UsingMultiDimExecutionRanges.html b/documentation/UsingMultiDimExecutionRanges.html
index 063a7718160c62fec9036c79437f89db74622f0d..27745de8f5be1918fb5518b78a497197b2ae1567 100644
--- a/documentation/UsingMultiDimExecutionRanges.html
+++ b/documentation/UsingMultiDimExecutionRanges.html
@@ -60,7 +60,7 @@
<p>Aparapi now allows developers to execute over one, two or three dimensional ranges. OpenCL natively allows the user to execute over 1, 2 or 3 dimension grids via the clEnqueueNDRangeKernel() method.</p>
- <p>Initially we chose not to expose 2D or 3D ranges (Aparapi’s Kernel.execute(range) allowed only !d ranges, but following a specific request we added the notion of a Range via the new com.amd.aparapi.Range class.</p>
+ <p>Initially we chose not to expose 2D or 3D ranges (Aparapi’s Kernel.execute(range) allowed only !d ranges, but following a specific request we added the notion of a Range via the new com.syncleus.aparapi.Range class.</p>
<p>A range is created using various static factory methods. For example to create a simple range {0..1024} we would use.</p>
diff --git a/index.html b/index.html
index e446a7f50a3633edd021f7e4bcfc5a4cf2902ce6..9613cf13ddf65a056592349b5aed31c36b326429 100644
--- a/index.html
+++ b/index.html
@@ -109,14 +109,6 @@
</div>
</div>
</div>
- <div class='divider'></div>
- <div class='section'>
- <div class='row center'>
- <h3 class='light header'>Aparapi Showcase</h3>
- <p class='col s8 offset-s2 caption'>Checkout what people are creating with Aparapi. Get inspired by these projects and you can even submit your own projects to be showcased here.</p>
- <a class='btn-large waves-effect waves-light' href='http://aparapi.com'>Explore our Showcase</a>
- </div>
- </div>
</div>
</main>
<footer class='page-footer'>
diff --git a/introduction/about.html b/introduction/about.html
index 19cb04431868b015db21abf825211b1b96f907f6..1c91c9e46b59dadcf28909ee6e0203d5867158d1 100644
--- a/introduction/about.html
+++ b/introduction/about.html
@@ -56,38 +56,6 @@
</div>
<div class='container'>
- <h1>What is Aparapi?</h1>
-
- <p>Aparapi allows Java developers to take advantage of the compute power of GPU and APU devices by executing data parallel code fragments on the GPU rather than being confined to the local CPU. It does this by converting Java bytecode to OpenCL at runtime and executing on the GPU, if for any reason Aparapi can’t execute on the GPU it will execute in a Java thread pool.</p>
-
- <p>We like to think that for the appropriate workload this extends Java’s ‘Write Once Run Anywhere’ to include GPU devices.</p>
-
- <p>With Aparapi we can take a sequential loop such as this (which adds each element from inA and inB arrays and puts the result in result).</p>
- <pre class="highlight java"><code>
- <span class="kd">final</span> <span class="kt">float</span> <span class="n">inA</span><span class="o">[]</span> <span class="o">=</span> <span class="o">....</span> <span class="c1">// get a float array of data from somewhere</span>
- <span class="kd">final</span> <span class="kt">float</span> <span class="n">inB</span><span class="o">[]</span> <span class="o">=</span> <span class="o">....</span> <span class="c1">// get a float array of data from somewhere</span>
- <span class="k">assert</span> <span class="o">(</span><span class="n">inA</span><span class="o">.</span><span class="na">length</span> <span class="o">==</span> <span class="n">inB</span><span class="o">.</span><span class="na">length</span><span class="o">);</span>
- <span class="kd">final</span> <span class="kt">float</span> <span class="n">result</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">float</span><span class="o">[</span><span class="n">inA</span><span class="o">.</span><span class="na">length</span><span class="o">];</span>
-
- <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">array</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
- <span class="n">result</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">=</span> <span class="n">intA</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">+</span> <span class="n">inB</span><span class="o">[</span><span class="n">i</span><span class="o">];</span>
- <span class="o">}</span>
- </code></pre>
- <p>And refactor the sequential loop to the following form:</p>
- <pre class="highlight java"><code>
- <span class="n">Kernel</span> <span class="n">kernel</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Kernel</span><span class="o">()</span> <span class="o">{</span>
- <span class="nd">@Override</span>
- <span class="kd">public</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
- <span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="n">getGlobalId</span><span class="o">();</span>
- <span class="n">result</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">=</span> <span class="n">intA</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">+</span> <span class="n">inB</span><span class="o">[</span><span class="n">i</span><span class="o">];</span>
- <span class="o">}</span>
- <span class="o">};</span>
-
- <span class="n">Range</span> <span class="n">range</span> <span class="o">=</span> <span class="n">Range</span><span class="o">.</span><span class="na">create</span><span class="o">(</span><span class="n">result</span><span class="o">.</span><span class="na">length</span><span class="o">);</span>
- <span class="n">kernel</span><span class="o">.</span><span class="na">execute</span><span class="o">(</span><span class="n">range</span><span class="o">);</span>
- </code></pre>
- <p>In the above code we extend com.amd.aparapi.Kernel base class and override the Kernel.run() method to express our data parallel algorithm. We initiate the execution of the Kernel(over a specific range 0..results.length) using Kernel.execute(range).</p>
-
<h1>About the Name</h1>
<p>Aparapi is just a contraction of “A PARallel API”</p>
diff --git a/introduction/getting-started.html b/introduction/getting-started.html
index ad653488fb88b8a51351a3f416a1334b2de08818..12ca764c162842b7a9ae8c67cf46b7a64fe6ce42 100644
--- a/introduction/getting-started.html
+++ b/introduction/getting-started.html
@@ -56,7 +56,66 @@
</div>
<div class='container'>
- <p><strong>Hello World!</strong></p>
+ <p>A framework for executing native Java code on the GPU.</p>
+
+ <p><strong>Licensed under the Apache Software License v2</strong></p>
+
+ <p>Aparapi allows developers to write native Javacode capable of being executed directly on a graphics card GPU by converting Java byte code to an OpenCL kernel dynamically at runtime. Because it is backed by OpenCL Aparapi is compatible with all OpenCL compatible Graphics Cards.</p>
+
+ <p>A GPU has a unique architecture that causes them to behave differently than a CPU. One of the most noticeable differences is that while a typical CPU has less than a dozen cores a high end GPU may have hundreds of cores. This makes them uniquely suited for data-parallel computation that can result in speedups hundreds of times more than what is capable with your average CPU. This can mean the difference between needing a whole data center to house your application versus just one or two computers, potentially saving millions in server costs.</p>
+
+ <p>Aparapi was originally a project conceived and developed by AMD corporation. It was later abandoned by AMD and sat mostly-idle for several years. Despite this there were some failed efforts by the community to keep the project alive, but without a clear community leader no new releases ever came. Eventually we came along and rescued the project, and modernized the project. Finally after such a long wait the first Aparapi release in 5 years was published and the community continues to push forward with renewed excitement.</p>
+
+ <p>For detailed documentation see <a href="http://Aparapi.com" rel="nofollow">Aparapi.com</a> or check out the <a href="http://www.javadoc.io/doc/com.syncleus.ferma/ferma" rel="nofollow">latest Javadocs</a>.</p>
+
+ <p>For support please use <a href="https://gitter.im/Syncleus/aparapi" rel="nofollow">Gitter</a> or the <a href="https://groups.google.com/a/syncleus.com/d/forum/aparapi-list" rel="nofollow">official Aparapi mailing list</a>.</p>
+
+ <p>Please file bugs and feature requests on <a href="https://github.com/Syncleus/aparapi/issues" rel="nofollow">Github</a>.</p>
+
+ <h2>Dependency</h2>
+
+ <p>To include Aparapi in your project of choice include the following Maven dependency into your build.</p>
+ <pre class="highlight xml"><code>
+ <span class="nt"><dependency></span>
+ <span class="nt"><groupId></span>com.syncleus.aparapi<span class="nt"></groupId></span>
+ <span class="nt"><artifactId></span>aparapi<span class="nt"></artifactId></span>
+ <span class="nt"><version></span>1.0.0<span class="nt"></version></span>
+ <span class="nt"></dependency></span>
+ </code></pre>
+ <h2>Obtaining the Source</h2>
+
+ <p>The official source repository for Aparapi is located in the Syncleus Github repository and can be cloned using the
+ following command.</p>
+ <pre class="highlight shell"><code>
+ git clone https://github.com/Syncleus/aparapi.git
+ </code></pre>
+ <h2>Getting Started</h2>
+
+ <p>With Aparapi we can take a sequential loop such as this (which adds each element from inA and inB arrays and puts the result in result).</p>
+ <pre class="highlight java"><code>
+ <span class="kd">final</span> <span class="kt">float</span> <span class="n">inA</span><span class="o">[]</span> <span class="o">=</span> <span class="o">....</span> <span class="c1">// get a float array of data from somewhere</span>
+ <span class="kd">final</span> <span class="kt">float</span> <span class="n">inB</span><span class="o">[]</span> <span class="o">=</span> <span class="o">....</span> <span class="c1">// get a float array of data from somewhere</span>
+ <span class="k">assert</span> <span class="o">(</span><span class="n">inA</span><span class="o">.</span><span class="na">length</span> <span class="o">==</span> <span class="n">inB</span><span class="o">.</span><span class="na">length</span><span class="o">);</span>
+ <span class="kd">final</span> <span class="kt">float</span> <span class="n">result</span> <span class="o">=</span> <span class="k">new</span> <span class="kt">float</span><span class="o">[</span><span class="n">inA</span><span class="o">.</span><span class="na">length</span><span class="o">];</span>
+
+ <span class="k">for</span> <span class="o">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="o">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">array</span><span class="o">.</span><span class="na">length</span><span class="o">;</span> <span class="n">i</span><span class="o">++)</span> <span class="o">{</span>
+ <span class="n">result</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">=</span> <span class="n">intA</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">+</span> <span class="n">inB</span><span class="o">[</span><span class="n">i</span><span class="o">];</span>
+ <span class="o">}</span>
+ </code></pre>
+ <p>And refactor the sequential loop to the following form:</p>
+ <pre class="highlight java"><code>
+ <span class="n">Kernel</span> <span class="n">kernel</span> <span class="o">=</span> <span class="k">new</span> <span class="n">Kernel</span><span class="o">()</span> <span class="o">{</span>
+ <span class="nd">@Override</span>
+ <span class="kd">public</span> <span class="kt">void</span> <span class="nf">run</span><span class="o">()</span> <span class="o">{</span>
+ <span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="n">getGlobalId</span><span class="o">();</span>
+ <span class="n">result</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">=</span> <span class="n">intA</span><span class="o">[</span><span class="n">i</span><span class="o">]</span> <span class="o">+</span> <span class="n">inB</span><span class="o">[</span><span class="n">i</span><span class="o">];</span>
+ <span class="o">}</span>
+ <span class="o">};</span>
+
+ <span class="n">Range</span> <span class="n">range</span> <span class="o">=</span> <span class="n">Range</span><span class="o">.</span><span class="na">create</span><span class="o">(</span><span class="n">result</span><span class="o">.</span><span class="na">length</span><span class="o">);</span>
+ <span class="n">kernel</span><span class="o">.</span><span class="na">execute</span><span class="o">(</span><span class="n">range</span><span class="o">);</span>
+ </code></pre>
+ <p>In the above code we extend com.syncleus.aparapi.Kernel base class and override the Kernel.run() method to express our data parallel algorithm. We initiate the execution of the Kernel(over a specific range 0..results.length) using Kernel.execute(range).</p>
</div>
</main>
<footer class='page-footer'>