(9419,18672,'2016-12-20 14:25:12','2016-12-20 19:25:12','In last week\'s \"<a href=\"http://sandbox.arrayfire.com/tag/learning-arrayfire-from-scratch/\">Learning ArrayFire from scratch</a>\" post we discussed how to interface ArrayFire and CUDA to improve your productivity. This week we demonstrate how to mix ArrayFire and OpenCL in your application.\r\n\r\n<!--more-->\r\n\r\nMuch like with CUDA, ArrayFire controls almost all aspects of its execution on OpenCL platforms. ArrayFire manages its own context, queue, memory, and creates custom IDs for devices. As such, most of the interoperability functions focus on reducing potential synchronization conflicts between ArrayFire and OpenCL.\r\n\r\n<strong>NOTE</strong>: This blog post was written against ArrayFire 3.3.x. We intend to implement additional convenience functions in ArrayFire 3.4 that should simplify this process further. Be sure to <a href=\"http://arrayfire.org/docs/interop_cuda.htm\">check the documentation</a> for any updates in future releases.\r\n<h4>Basics</h4>\r\nIt is fairly straightforward to interface ArrayFire with your own custom OpenCL code. ArrayFire provides several functions to ease this process including:\r\n<table class=\"doxtable\">\r\n<tbody>\r\n<tr>\r\n<th>Function</th>\r\n<th>Purpose</th>\r\n</tr>\r\n<tr>\r\n<td><code>af::array(...)</code></td>\r\n<td>Construct an ArrayFire array from cl_mem references or cl::Buffer objects</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::array.device()</code></td>\r\n<td>Obtain a pointer to the cl_mem reference (implies lock())</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::array.lock()</code></td>\r\n<td>Removes ArrayFire\'s control of a cl_mem buffer</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::array.unlock()</code></td>\r\n<td>Restore\'s ArrayFire\'s control over a cl_mem buffer</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getPlatform()</code></td>\r\n<td>Get ArrayFire\'s current cl_platform</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::getDevice()</code></td>\r\n<td>Get the current ArrayFire Device ID</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getDeviceId()</code></td>\r\n<td>Get ArrayFire\'s current cl_device_id</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::setDevice()</code></td>\r\n<td>Set ArrayFire\'s device from an ArrayFire device ID</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::setDeviceId()</code></td>\r\n<td>Set ArrayFire\'s device from a cl_device_id</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::setDevice()</code></td>\r\n<td>Set ArrayFire\'s device from a cl_device_id and cl_context</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getContext()</code></td>\r\n<td>Get ArrayFire\'s current cl_context</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getQueue()</code></td>\r\n<td>Get ArrayFire\'s current cl_command_queue</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getDeviceType()</code></td>\r\n<td>Get the current afcl_device_type</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\nAdditionally, the OpenCL backend permits the programmer to add and remove custom devices from the ArrayFire device manager. These permit you to attach ArrayFire directly to the OpenCL queue used by other portions of your application.\r\n<table class=\"doxtable\">\r\n<tbody>\r\n<tr>\r\n<th>Function</th>\r\n<th>Purpose</th>\r\n</tr>\r\n<tr>\r\n<td>afcl::addDevice()</td>\r\n<td>Add a new device to ArrayFire\'s device manager</td>\r\n</tr>\r\n<tr>\r\n<td>afcl::deleteDevice()</td>\r\n<td>Remove a device from ArrayFire\'s device manager</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\nBelow we provide two worked examples on how ArrayFire can be integrated into new and existing projects.\r\n<h4>Adding custom OpenCL kernels to an existing ArrayFire application</h4>\r\nBy default, ArrayFire manages its own context, queue, memory, and creates custom IDs for devices. Thus there is some bookkeeping that needs to be done to integrate your custom OpenCL kernel.\r\n\r\nIf your kernels can share operate in the same queue as ArrayFire, you should:\r\n<ol type=\"1\">\r\n 	<li>Add an include for <code>af/opencl.h</code> to your project</li>\r\n 	<li>Obtain the OpenCL context, device, and queue used by ArrayFire</li>\r\n 	<li>Obtain cl_mem references to af::array objects</li>\r\n 	<li>Load, build, and use your kernels</li>\r\n 	<li>Return control of af::array memory to ArrayFire</li>\r\n</ol>\r\nNote, ArrayFire uses an in-order queue, thus when ArrayFire and your kernels are operating in the same queue, there is no need to perform any synchronization operations.\r\n\r\nThis process is best illustrated with a fully worked example:\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">#include &lt;arrayfire.h&gt;\r\n// 1. Add the af/opencl.h include to your project\r\n#include &lt;af/opencl.h&gt;\r\n \r\nint main() {\r\nsize_t length = 10;\r\n \r\n// Create ArrayFire array objects:\r\naf::array A = af::randu(length, f32);\r\naf::array B = af::constant(0, length, f32);\r\n \r\n// ... additional ArrayFire operations here\r\n \r\n// 2. Obtain the device, context, and queue used by ArrayFire\r\nstatic cl_context af_context = afcl::getContext();\r\nstatic cl_device_id af_device_id = afcl::getDeviceId();\r\nstatic cl_command_queue af_queue = afcl::getQueue();\r\n \r\n// 3. Obtain cl_mem references to af::array objects\r\ncl_mem * d_A = A.device&lt;cl_mem&gt;();\r\ncl_mem * d_B = B.device&lt;cl_mem&gt;();\r\n \r\n// 4. Load, build, and use your kernels.\r\n// For the sake of readability, we have omitted error checking.\r\nint status = CL_SUCCESS;\r\n \r\n// A simple copy kernel, uses C++11 syntax for multi-line strings.\r\nconst char * kernel_name = \"copy_kernel\";\r\nconst char * source = R\"(\r\nvoid __kernel\r\ncopy_kernel(__global float * gA, __global float * gB)\r\n{\r\nint id = get_global_id(0);\r\ngB[id] = gA[id];\r\n}\r\n)\";\r\n \r\n// Create the program, build the executable, and extract the entry point\r\n// for the kernel.\r\ncl_program program = clCreateProgramWithSource(af_context, 1, &amp;source, NULL, &amp;status);\r\nstatus = clBuildProgram(program, 1, &amp;af_device_id, NULL, NULL, NULL);\r\ncl_kernel kernel = clCreateKernel(program, kernel_name, &amp;status);\r\n \r\n// Set arguments and launch your kernels\r\nclSetKernelArg(kernel, 0, sizeof(cl_mem), d_A);\r\nclSetKernelArg(kernel, 1, sizeof(cl_mem), d_B);\r\nclEnqueueNDRangeKernel(af_queue, kernel, 1, NULL, &amp;length, NULL, 0, NULL, NULL);\r\n \r\n// 5. Return control of af::array memory to ArrayFire\r\nA.unlock();\r\nB.unlock();\r\n \r\n// ... resume ArrayFire operations\r\n \r\n// Because the device pointers, d_x and d_y, were returned to ArrayFire\'s\r\n// control by the unlock function, there is no need to free them using\r\n// clReleaseMemObject()\r\n \r\nreturn 0;\r\n}</pre>\r\n</div>\r\n</div>\r\nIf your kernels needs to operate in their own OpenCL queue, the process is essentially identical, except you need to instruct ArrayFire to complete its computations using the af::sync() function prior to launching your own kernel and ensure your kernels are complete using <code>clFinish</code> (or similar) commands prior to returning control of the memory to ArrayFire:\r\n<ol type=\"1\">\r\n 	<li>Add an include for <code>af/opencl.h</code> to your project</li>\r\n 	<li>Obtain the OpenCL context, device, and queue used by ArrayFire</li>\r\n 	<li>Obtain cl_mem references to af::array objects</li>\r\n 	<li>Instruct ArrayFire to finish operations using af::sync()</li>\r\n 	<li>Load, build, and use your kernels</li>\r\n 	<li>Instruct OpenCL to finish operations using clFinish() or similar commands.</li>\r\n</ol>\r\n<ol type=\"1\">\r\n 	<li>Return control of af::array memory to ArrayFire</li>\r\n</ol>\r\n<h4>Adding ArrayFire to an existing OpenCL application</h4>\r\nAdding ArrayFire to an existing OpenCL application is slightly more involved and can be somewhat tricky due to several optimizations we implement. The most important are as follows:\r\n<ul>\r\n 	<li>ArrayFire assumes control of all memory provided to it.</li>\r\n 	<li>ArrayFire does not (in general) support in-place memory transactions.</li>\r\n</ul>\r\nWe will discuss the implications of these items below. To add ArrayFire to existing code you need to:\r\n<ol type=\"1\">\r\n 	<li>Add includes</li>\r\n 	<li>Instruct OpenCL to complete its operations using clFinish (or similar)</li>\r\n 	<li>Instruct ArrayFire to use the user-created OpenCL Context</li>\r\n 	<li>Create ArrayFire arrays from OpenCL memory objects</li>\r\n 	<li>Perform ArrayFire operations on the Arrays</li>\r\n 	<li>Instruct ArrayFire to finish operations using af::sync()</li>\r\n 	<li>Obtain cl_mem references for important memory</li>\r\n 	<li>Continue your OpenCL application</li>\r\n</ol>\r\nTo create the af::array objects, you should use one of the following constructors:\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">// 1D - 3D af::array constructors\r\nstatic af::array array (dim_t dim0, cl_mem buf, af::dtype type, bool retain=false)\r\nstatic af::array array (dim_t dim0, dim_t dim1, cl_mem buf, af::dtype type, bool retain=false)\r\nstatic af::array array (dim_t dim0, dim_t dim1, dim_t dim2, cl_mem buf, af::dtype type, bool retain=false)\r\nstatic af::array array (dim_t dim0, dim_t dim1, dim_t dim2, dim_t dim3, cl_mem buf, af::dtype type, bool retain=false)\r\n \r\n// af::array constructor using a dim4 object\r\nstatic af::array array (af::dim4 idims, cl_mem buf, af::dtype type, bool retain=false)</pre>\r\n</div>\r\n</div>\r\n<em>NOTE</em>: With all of these constructors, ArrayFire\'s memory manager automatically assumes responsibility for any memory provided to it. If you are creating an array from a <code>cl::Buffer</code>, you should specify <code>retain=true</code> to ensure your memory is not deallocated if your <code>cl::Buffer</code> were to go out of scope. We use this technique in the example below. If you do not wish for ArrayFire to manage your memory, you may call the <code>array::unlock()</code> function and manage the memory yourself; however, if you do so, please be cautious not to call <code>clReleaseMemObj</code> on a <code>cl_mem</code> when ArrayFire might be using it!\r\n\r\nThe eight steps above are best illustrated using a fully-worked example. Below we use the OpenCL 2.0 C++ API and omit error checking to keep the code readable.\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">#include &lt;CL/cl2.hpp&gt;\r\n \r\n// 1. Add arrayfire.h and af/opencl.h to your application\r\n#include \"arrayfire.h\"\r\n#include \"af/opencl.h\"\r\n \r\n#include &lt;cstdio&gt;\r\n#include &lt;vector&gt;\r\n \r\nint main() {\r\n \r\n// Set up the OpenCL context, device, and queues\r\ncl::Context context(CL_DEVICE_TYPE_ALL);\r\nvector&lt;cl::Device&gt; devices = context.getInfo&lt;CL_CONTEXT_DEVICES&gt;();\r\ncl::Device device = devices[0];\r\ncl::CommandQueue queue(context, device);\r\n \r\n// Create a buffer of size 10 filled with ones, copy it to the device\r\nint length = 10;\r\nvector&lt;float&gt; h_A(length, 1);\r\ncl::Buffer cl_A(context, CL_MEM_READ_WRITE, length * sizeof(float), h_A.data());\r\n \r\n// 2. Instruct OpenCL to complete its operations using clFinish (or similar)\r\nqueue.finish();\r\n \r\n// 3. Instruct ArrayFire to use the user-created context\r\n// First, create a device from the current OpenCL device + context + queue\r\nafcl::addDevice(device(), context(), queue());\r\n// Next switch ArrayFire to the device using the device and context as\r\n// identifiers:\r\nafcl::setDevice(device(), context());\r\n \r\n// 4. Create ArrayFire arrays from OpenCL memory objects\r\naf::array af_A = afcl::array(length, cl_A(), f32, true);\r\n \r\n// 5. Perform ArrayFire operations on the Arrays\r\naf_A = af_A + af::randu(length);\r\n \r\n// NOTE: ArrayFire does not perform the above transaction using in-place memory,\r\n// thus the underlying OpenCL buffers containing the memory containing memory to\r\n// probably have changed\r\n \r\n// 6. Instruct ArrayFire to finish operations using af::sync\r\naf::sync();\r\n \r\n// 7. Obtain cl_mem references for important memory\r\ncl_A = *af_A.device&lt;cl_mem&gt;();\r\n \r\n// 8. Continue your OpenCL application\r\n \r\n// ...\r\n \r\nreturn 0;\r\n}</pre>\r\n</div>\r\n</div>\r\n<h4>Using multiple devices</h4>\r\nIf you are using ArrayFire and OpenCL with multiple devices be sure to use <code>afcl::addDevice</code> to add your custom context + device + queue to ArrayFire\'s device manager. This will let you switch ArrayFire devices using your current<code>cl_device_id</code> and <code>cl_context</code>.','ArrayFire - OpenCL Interoperability','','inherit','closed','closed','','8874-revision-v1','','','2016-12-20 14:25:12','2016-12-20 19:25:12','',8874,'http://sandbox.arrayfire.com/8874-revision-v1/',0,'revision','',0),(9420,18672,'2016-12-20 14:31:29','2016-12-20 19:31:29','In last week\'s \"<a href=\"http://sandbox.arrayfire.com/tag/learning-arrayfire-from-scratch/\">Learning ArrayFire from scratch</a>\" post we discussed how to interface ArrayFire and CUDA to improve your productivity. This week we demonstrate how to mix ArrayFire and OpenCL in your application.\r\n\r\n<!--more-->\r\n\r\nMuch like with CUDA, ArrayFire controls almost all aspects of its execution on OpenCL platforms. ArrayFire manages its own context, queue, memory, and creates custom IDs for devices. As such, most of the interoperability functions focus on reducing potential synchronization conflicts between ArrayFire and OpenCL.\r\n\r\n<strong>NOTE</strong>: This blog post was written against ArrayFire 3.3.x. We intend to implement additional convenience functions in ArrayFire 3.4 that should simplify this process further. Be sure to <a href=\"http://arrayfire.org/docs/interop_cuda.htm\">check the documentation</a> for any updates in future releases.\r\n<h4>Basics</h4>\r\nIt is fairly straightforward to interface ArrayFire with your own custom OpenCL code. ArrayFire provides several functions to ease this process including:\r\n<table class=\"doxtable\">\r\n<tbody>\r\n<tr>\r\n<th>Function</th>\r\n<th>Purpose</th>\r\n</tr>\r\n<tr>\r\n<td><code>af::array(...)</code></td>\r\n<td>Construct an ArrayFire array from <code>cl_mem<code> references or <code>cl::Buffer</code> objects</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::array.device()</code></td>\r\n<td>Obtain a pointer to the <code>cl_mem</code> reference (implies lock())</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::array.lock()</code></td>\r\n<td>Removes ArrayFire\'s control of a <code>cl_mem</code> buffer</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::array.unlock()</code></td>\r\n<td>Restore\'s ArrayFire\'s control over a <code>cl_mem</code> buffer</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getPlatform()</code></td>\r\n<td>Get ArrayFire\'s current <code>cl_platform</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>af::getDevice()</code></td>\r\n<td>Get the current ArrayFire Device ID</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getDeviceId()</code></td>\r\n<td>Get ArrayFire\'s current <code>cl_device_id</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>af::setDevice()</code></td>\r\n<td>Set ArrayFire\'s device from an ArrayFire device ID</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::setDeviceId()</code></td>\r\n<td>Set ArrayFire\'s device from a <code>cl_device_id</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::setDevice()</code></td>\r\n<td>Set ArrayFire\'s device from a <code>cl_device_id</code> and <code>cl_context</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getContext()</code></td>\r\n<td>Get ArrayFire\'s current <code>cl_context</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getQueue()</code></td>\r\n<td>Get ArrayFire\'s current <code>cl_command_queue</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getDeviceType()</code></td>\r\n<td>Get the current <code>afcl_device_type</code></td>\r\n</tr>\r\n</tbody>\r\n</table>\r\nAdditionally, the OpenCL backend permits the programmer to add and remove custom devices from the ArrayFire device manager. These permit you to attach ArrayFire directly to the OpenCL queue used by other portions of your application.\r\n<table class=\"doxtable\">\r\n<tbody>\r\n<tr>\r\n<th>Function</th>\r\n<th>Purpose</th>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::addDevice()</code></td>\r\n<td>Add a new device to ArrayFire\'s device manager</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::deleteDevice()</code></td>\r\n<td>Remove a device from ArrayFire\'s device manager</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\nBelow we provide two worked examples on how ArrayFire can be integrated into new and existing projects.\r\n<h4>Adding custom OpenCL kernels to an existing ArrayFire application</h4>\r\nBy default, ArrayFire manages its own context, queue, memory, and creates custom IDs for devices. Thus there is some bookkeeping that needs to be done to integrate your custom OpenCL kernel.\r\n\r\nIf your kernels can share operate in the same queue as ArrayFire, you should:\r\n<ol type=\"1\">\r\n 	<li>Add an include for <code>af/opencl.h</code> to your project</li>\r\n 	<li>Obtain the OpenCL context, device, and queue used by ArrayFire</li>\r\n 	<li>Obtain <code>cl_mem</code> references to <code>af::array</code> objects</li>\r\n 	<li>Load, build, and use your kernels</li>\r\n 	<li>Return control of <code>af::array</code> memory to ArrayFire</li>\r\n</ol>\r\nNote, ArrayFire uses an in-order queue, thus when ArrayFire and your kernels are operating in the same queue, there is no need to perform any synchronization operations.\r\n\r\nThis process is best illustrated with a fully worked example:\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">#include &lt;arrayfire.h&gt;\r\n// 1. Add the af/opencl.h include to your project\r\n#include &lt;af/opencl.h&gt;\r\n \r\nint main() {\r\nsize_t length = 10;\r\n \r\n// Create ArrayFire array objects:\r\naf::array A = af::randu(length, f32);\r\naf::array B = af::constant(0, length, f32);\r\n \r\n// ... additional ArrayFire operations here\r\n \r\n// 2. Obtain the device, context, and queue used by ArrayFire\r\nstatic cl_context af_context = afcl::getContext();\r\nstatic cl_device_id af_device_id = afcl::getDeviceId();\r\nstatic cl_command_queue af_queue = afcl::getQueue();\r\n \r\n// 3. Obtain cl_mem references to af::array objects\r\ncl_mem * d_A = A.device&lt;cl_mem&gt;();\r\ncl_mem * d_B = B.device&lt;cl_mem&gt;();\r\n \r\n// 4. Load, build, and use your kernels.\r\n// For the sake of readability, we have omitted error checking.\r\nint status = CL_SUCCESS;\r\n \r\n// A simple copy kernel, uses C++11 syntax for multi-line strings.\r\nconst char * kernel_name = \"copy_kernel\";\r\nconst char * source = R\"(\r\nvoid __kernel\r\ncopy_kernel(__global float * gA, __global float * gB)\r\n{\r\nint id = get_global_id(0);\r\ngB[id] = gA[id];\r\n}\r\n)\";\r\n \r\n// Create the program, build the executable, and extract the entry point\r\n// for the kernel.\r\ncl_program program = clCreateProgramWithSource(af_context, 1, &amp;source, NULL, &amp;status);\r\nstatus = clBuildProgram(program, 1, &amp;af_device_id, NULL, NULL, NULL);\r\ncl_kernel kernel = clCreateKernel(program, kernel_name, &amp;status);\r\n \r\n// Set arguments and launch your kernels\r\nclSetKernelArg(kernel, 0, sizeof(cl_mem), d_A);\r\nclSetKernelArg(kernel, 1, sizeof(cl_mem), d_B);\r\nclEnqueueNDRangeKernel(af_queue, kernel, 1, NULL, &amp;length, NULL, 0, NULL, NULL);\r\n \r\n// 5. Return control of af::array memory to ArrayFire\r\nA.unlock();\r\nB.unlock();\r\n \r\n// ... resume ArrayFire operations\r\n \r\n// Because the device pointers, d_x and d_y, were returned to ArrayFire\'s\r\n// control by the unlock function, there is no need to free them using\r\n// clReleaseMemObject()\r\n \r\nreturn 0;\r\n}</pre>\r\n</div>\r\n</div>\r\nIf your kernels needs to operate in their own OpenCL queue, the process is essentially identical, except you need to instruct ArrayFire to complete its computations using the <code>af::sync()</code> function prior to launching your own kernel and ensure your kernels are complete using <code>clFinish</code> (or similar) commands prior to returning control of the memory to ArrayFire:\r\n<ol type=\"1\">\r\n 	<li>Add an include for <code>af/opencl.h</code> to your project</li>\r\n 	<li>Obtain the OpenCL context, device, and queue used by ArrayFire</li>\r\n 	<li>Obtain <code>cl_mem</code> references to <code>af::array</code> objects</li>\r\n 	<li>Instruct ArrayFire to finish operations using <code>af::sync()</code></li>\r\n 	<li>Load, build, and use your kernels</li>\r\n 	<li>Instruct OpenCL to finish operations using <code>clFinish()</code> or similar commands</li>\r\n</ol>\r\n<ol type=\"1\">\r\n 	<li>Return control of <code>af::array</code> memory to ArrayFire</li>\r\n</ol>\r\n<h4>Adding ArrayFire to an existing OpenCL application</h4>\r\nAdding ArrayFire to an existing OpenCL application is slightly more involved and can be somewhat tricky due to several optimizations we implement. The most important are as follows:\r\n<ul>\r\n 	<li>ArrayFire assumes control of all memory provided to it.</li>\r\n 	<li>ArrayFire does not (in general) support in-place memory transactions.</li>\r\n</ul>\r\nWe will discuss the implications of these items below. To add ArrayFire to existing code you need to:\r\n<ol type=\"1\">\r\n 	<li>Add includes</li>\r\n 	<li>Instruct OpenCL to complete its operations using <code>clFinish</code> (or similar)</li>\r\n 	<li>Instruct ArrayFire to use the user-created OpenCL Context</li>\r\n 	<li>Create ArrayFire arrays from OpenCL memory objects</li>\r\n 	<li>Perform ArrayFire operations on the Arrays</li>\r\n 	<li>Instruct ArrayFire to finish operations using <code>af::sync()</code></li>\r\n 	<li>Obtain cl_mem references for important memory</li>\r\n 	<li>Continue your OpenCL application</li>\r\n</ol>\r\nTo create the af::array objects, you should use one of the following constructors:\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">// 1D - 3D af::array constructors\r\nstatic af::array array (dim_t dim0, cl_mem buf, af::dtype type, bool retain=false)\r\nstatic af::array array (dim_t dim0, dim_t dim1, cl_mem buf, af::dtype type, bool retain=false)\r\nstatic af::array array (dim_t dim0, dim_t dim1, dim_t dim2, cl_mem buf, af::dtype type, bool retain=false)\r\nstatic af::array array (dim_t dim0, dim_t dim1, dim_t dim2, dim_t dim3, cl_mem buf, af::dtype type, bool retain=false)\r\n \r\n// af::array constructor using a dim4 object\r\nstatic af::array array (af::dim4 idims, cl_mem buf, af::dtype type, bool retain=false)</pre>\r\n</div>\r\n</div>\r\n<em>NOTE</em>: With all of these constructors, ArrayFire\'s memory manager automatically assumes responsibility for any memory provided to it. If you are creating an array from a <code>cl::Buffer</code>, you should specify <code>retain=true</code> to ensure your memory is not deallocated if your <code>cl::Buffer</code> were to go out of scope. We use this technique in the example below. If you do not wish for ArrayFire to manage your memory, you may call the <code>array::unlock()</code> function and manage the memory yourself; however, if you do so, please be cautious not to call <code>clReleaseMemObj</code> on a <code>cl_mem</code> when ArrayFire might be using it!\r\n\r\nThe eight steps above are best illustrated using a fully-worked example. Below we use the OpenCL 2.0 C++ API and omit error checking to keep the code readable.\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">#include &lt;CL/cl2.hpp&gt;\r\n \r\n// 1. Add arrayfire.h and af/opencl.h to your application\r\n#include \"arrayfire.h\"\r\n#include \"af/opencl.h\"\r\n \r\n#include &lt;cstdio&gt;\r\n#include &lt;vector&gt;\r\n \r\nint main() {\r\n \r\n// Set up the OpenCL context, device, and queues\r\ncl::Context context(CL_DEVICE_TYPE_ALL);\r\nvector&lt;cl::Device&gt; devices = context.getInfo&lt;CL_CONTEXT_DEVICES&gt;();\r\ncl::Device device = devices[0];\r\ncl::CommandQueue queue(context, device);\r\n \r\n// Create a buffer of size 10 filled with ones, copy it to the device\r\nint length = 10;\r\nvector&lt;float&gt; h_A(length, 1);\r\ncl::Buffer cl_A(context, CL_MEM_READ_WRITE, length * sizeof(float), h_A.data());\r\n \r\n// 2. Instruct OpenCL to complete its operations using clFinish (or similar)\r\nqueue.finish();\r\n \r\n// 3. Instruct ArrayFire to use the user-created context\r\n// First, create a device from the current OpenCL device + context + queue\r\nafcl::addDevice(device(), context(), queue());\r\n// Next switch ArrayFire to the device using the device and context as\r\n// identifiers:\r\nafcl::setDevice(device(), context());\r\n \r\n// 4. Create ArrayFire arrays from OpenCL memory objects\r\naf::array af_A = afcl::array(length, cl_A(), f32, true);\r\n \r\n// 5. Perform ArrayFire operations on the Arrays\r\naf_A = af_A + af::randu(length);\r\n \r\n// NOTE: ArrayFire does not perform the above transaction using in-place memory,\r\n// thus the underlying OpenCL buffers containing the memory containing memory to\r\n// probably have changed\r\n \r\n// 6. Instruct ArrayFire to finish operations using af::sync\r\naf::sync();\r\n \r\n// 7. Obtain cl_mem references for important memory\r\ncl_A = *af_A.device&lt;cl_mem&gt;();\r\n \r\n// 8. Continue your OpenCL application\r\n \r\n// ...\r\n \r\nreturn 0;\r\n}</pre>\r\n</div>\r\n</div>\r\n<h4>Using multiple devices</h4>\r\nIf you are using ArrayFire and OpenCL with multiple devices be sure to use <code>afcl::addDevice</code> to add your custom context + device + queue to ArrayFire\'s device manager. This will let you switch ArrayFire devices using your current<code>cl_device_id</code> and <code>cl_context</code>.','ArrayFire - OpenCL Interoperability','','inherit','closed','closed','','8874-revision-v1','','','2016-12-20 14:31:29','2016-12-20 19:31:29','',8874,'http://sandbox.arrayfire.com/8874-revision-v1/',0,'revision','',0),(9421,18672,'2016-12-20 14:33:04','2016-12-20 19:33:04','In last week\'s \"<a href=\"http://sandbox.arrayfire.com/tag/learning-arrayfire-from-scratch/\">Learning ArrayFire from scratch</a>\" post we discussed how to interface ArrayFire and CUDA to improve your productivity. This week we demonstrate how to mix ArrayFire and OpenCL in your application.\r\n\r\n<!--more-->\r\n\r\nMuch like with CUDA, ArrayFire controls almost all aspects of its execution on OpenCL platforms. ArrayFire manages its own context, queue, memory, and creates custom IDs for devices. As such, most of the interoperability functions focus on reducing potential synchronization conflicts between ArrayFire and OpenCL.\r\n\r\n<strong>NOTE</strong>: This blog post was written against ArrayFire 3.3.x. We intend to implement additional convenience functions in ArrayFire 3.4 that should simplify this process further. Be sure to <a href=\"http://arrayfire.org/docs/interop_cuda.htm\">check the documentation</a> for any updates in future releases.\r\n<h4>Basics</h4>\r\nIt is fairly straightforward to interface ArrayFire with your own custom OpenCL code. ArrayFire provides several functions to ease this process including:\r\n<table class=\"doxtable\">\r\n<tbody>\r\n<tr>\r\n<th>Function</th>\r\n<th>Purpose</th>\r\n</tr>\r\n<tr>\r\n<td><code>af::array(...)</code></td>\r\n<td>Construct an ArrayFire array from <code>cl_mem</code> references or <code>cl::Buffer</code> objects</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::array.device()</code></td>\r\n<td>Obtain a pointer to the <code>cl_mem</code> reference (implies lock())</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::array.lock()</code></td>\r\n<td>Removes ArrayFire\'s control of a <code>cl_mem</code> buffer</td>\r\n</tr>\r\n<tr>\r\n<td><code>af::array.unlock()</code></td>\r\n<td>Restore\'s ArrayFire\'s control over a <code>cl_mem</code> buffer</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getPlatform()</code></td>\r\n<td>Get ArrayFire\'s current <code>cl_platform</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>af::getDevice()</code></td>\r\n<td>Get the current ArrayFire Device ID</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getDeviceId()</code></td>\r\n<td>Get ArrayFire\'s current <code>cl_device_id</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>af::setDevice()</code></td>\r\n<td>Set ArrayFire\'s device from an ArrayFire device ID</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::setDeviceId()</code></td>\r\n<td>Set ArrayFire\'s device from a <code>cl_device_id</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::setDevice()</code></td>\r\n<td>Set ArrayFire\'s device from a <code>cl_device_id</code> and <code>cl_context</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getContext()</code></td>\r\n<td>Get ArrayFire\'s current <code>cl_context</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getQueue()</code></td>\r\n<td>Get ArrayFire\'s current <code>cl_command_queue</code></td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::getDeviceType()</code></td>\r\n<td>Get the current <code>afcl_device_type</code></td>\r\n</tr>\r\n</tbody>\r\n</table>\r\nAdditionally, the OpenCL backend permits the programmer to add and remove custom devices from the ArrayFire device manager. These permit you to attach ArrayFire directly to the OpenCL queue used by other portions of your application.\r\n<table class=\"doxtable\">\r\n<tbody>\r\n<tr>\r\n<th>Function</th>\r\n<th>Purpose</th>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::addDevice()</code></td>\r\n<td>Add a new device to ArrayFire\'s device manager</td>\r\n</tr>\r\n<tr>\r\n<td><code>afcl::deleteDevice()</code></td>\r\n<td>Remove a device from ArrayFire\'s device manager</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\nBelow we provide two worked examples on how ArrayFire can be integrated into new and existing projects.\r\n<h4>Adding custom OpenCL kernels to an existing ArrayFire application</h4>\r\nBy default, ArrayFire manages its own context, queue, memory, and creates custom IDs for devices. Thus there is some bookkeeping that needs to be done to integrate your custom OpenCL kernel.\r\n\r\nIf your kernels can share operate in the same queue as ArrayFire, you should:\r\n<ol type=\"1\">\r\n 	<li>Add an include for <code>af/opencl.h</code> to your project</li>\r\n 	<li>Obtain the OpenCL context, device, and queue used by ArrayFire</li>\r\n 	<li>Obtain <code>cl_mem</code> references to <code>af::array</code> objects</li>\r\n 	<li>Load, build, and use your kernels</li>\r\n 	<li>Return control of <code>af::array</code> memory to ArrayFire</li>\r\n</ol>\r\nNote, ArrayFire uses an in-order queue, thus when ArrayFire and your kernels are operating in the same queue, there is no need to perform any synchronization operations.\r\n\r\nThis process is best illustrated with a fully worked example:\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">#include &lt;arrayfire.h&gt;\r\n// 1. Add the af/opencl.h include to your project\r\n#include &lt;af/opencl.h&gt;\r\n \r\nint main() {\r\nsize_t length = 10;\r\n \r\n// Create ArrayFire array objects:\r\naf::array A = af::randu(length, f32);\r\naf::array B = af::constant(0, length, f32);\r\n \r\n// ... additional ArrayFire operations here\r\n \r\n// 2. Obtain the device, context, and queue used by ArrayFire\r\nstatic cl_context af_context = afcl::getContext();\r\nstatic cl_device_id af_device_id = afcl::getDeviceId();\r\nstatic cl_command_queue af_queue = afcl::getQueue();\r\n \r\n// 3. Obtain cl_mem references to af::array objects\r\ncl_mem * d_A = A.device&lt;cl_mem&gt;();\r\ncl_mem * d_B = B.device&lt;cl_mem&gt;();\r\n \r\n// 4. Load, build, and use your kernels.\r\n// For the sake of readability, we have omitted error checking.\r\nint status = CL_SUCCESS;\r\n \r\n// A simple copy kernel, uses C++11 syntax for multi-line strings.\r\nconst char * kernel_name = \"copy_kernel\";\r\nconst char * source = R\"(\r\nvoid __kernel\r\ncopy_kernel(__global float * gA, __global float * gB)\r\n{\r\nint id = get_global_id(0);\r\ngB[id] = gA[id];\r\n}\r\n)\";\r\n \r\n// Create the program, build the executable, and extract the entry point\r\n// for the kernel.\r\ncl_program program = clCreateProgramWithSource(af_context, 1, &amp;source, NULL, &amp;status);\r\nstatus = clBuildProgram(program, 1, &amp;af_device_id, NULL, NULL, NULL);\r\ncl_kernel kernel = clCreateKernel(program, kernel_name, &amp;status);\r\n \r\n// Set arguments and launch your kernels\r\nclSetKernelArg(kernel, 0, sizeof(cl_mem), d_A);\r\nclSetKernelArg(kernel, 1, sizeof(cl_mem), d_B);\r\nclEnqueueNDRangeKernel(af_queue, kernel, 1, NULL, &amp;length, NULL, 0, NULL, NULL);\r\n \r\n// 5. Return control of af::array memory to ArrayFire\r\nA.unlock();\r\nB.unlock();\r\n \r\n// ... resume ArrayFire operations\r\n \r\n// Because the device pointers, d_x and d_y, were returned to ArrayFire\'s\r\n// control by the unlock function, there is no need to free them using\r\n// clReleaseMemObject()\r\n \r\nreturn 0;\r\n}</pre>\r\n</div>\r\n</div>\r\nIf your kernels needs to operate in their own OpenCL queue, the process is essentially identical, except you need to instruct ArrayFire to complete its computations using the <code>af::sync()</code> function prior to launching your own kernel and ensure your kernels are complete using <code>clFinish</code> (or similar) commands prior to returning control of the memory to ArrayFire:\r\n<ol type=\"1\">\r\n 	<li>Add an include for <code>af/opencl.h</code> to your project</li>\r\n 	<li>Obtain the OpenCL context, device, and queue used by ArrayFire</li>\r\n 	<li>Obtain <code>cl_mem</code> references to <code>af::array</code> objects</li>\r\n 	<li>Instruct ArrayFire to finish operations using <code>af::sync()</code></li>\r\n 	<li>Load, build, and use your kernels</li>\r\n 	<li>Instruct OpenCL to finish operations using <code>clFinish()</code> or similar commands</li>\r\n        <li>Return control of <code>af::array</code> memory to ArrayFire</li>\r\n</ol>\r\n<h4>Adding ArrayFire to an existing OpenCL application</h4>\r\nAdding ArrayFire to an existing OpenCL application is slightly more involved and can be somewhat tricky due to several optimizations we implement. The most important are as follows:\r\n<ul>\r\n 	<li>ArrayFire assumes control of all memory provided to it.</li>\r\n 	<li>ArrayFire does not (in general) support in-place memory transactions.</li>\r\n</ul>\r\nWe will discuss the implications of these items below. To add ArrayFire to existing code you need to:\r\n<ol type=\"1\">\r\n 	<li>Add includes</li>\r\n 	<li>Instruct OpenCL to complete its operations using <code>clFinish</code> (or similar)</li>\r\n 	<li>Instruct ArrayFire to use the user-created OpenCL Context</li>\r\n 	<li>Create ArrayFire arrays from OpenCL memory objects</li>\r\n 	<li>Perform ArrayFire operations on the Arrays</li>\r\n 	<li>Instruct ArrayFire to finish operations using <code>af::sync()</code></li>\r\n 	<li>Obtain cl_mem references for important memory</li>\r\n 	<li>Continue your OpenCL application</li>\r\n</ol>\r\nTo create the af::array objects, you should use one of the following constructors:\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">// 1D - 3D af::array constructors\r\nstatic af::array array (dim_t dim0, cl_mem buf, af::dtype type, bool retain=false)\r\nstatic af::array array (dim_t dim0, dim_t dim1, cl_mem buf, af::dtype type, bool retain=false)\r\nstatic af::array array (dim_t dim0, dim_t dim1, dim_t dim2, cl_mem buf, af::dtype type, bool retain=false)\r\nstatic af::array array (dim_t dim0, dim_t dim1, dim_t dim2, dim_t dim3, cl_mem buf, af::dtype type, bool retain=false)\r\n \r\n// af::array constructor using a dim4 object\r\nstatic af::array array (af::dim4 idims, cl_mem buf, af::dtype type, bool retain=false)</pre>\r\n</div>\r\n</div>\r\n<em>NOTE</em>: With all of these constructors, ArrayFire\'s memory manager automatically assumes responsibility for any memory provided to it. If you are creating an array from a <code>cl::Buffer</code>, you should specify <code>retain=true</code> to ensure your memory is not deallocated if your <code>cl::Buffer</code> were to go out of scope. We use this technique in the example below. If you do not wish for ArrayFire to manage your memory, you may call the <code>array::unlock()</code> function and manage the memory yourself; however, if you do so, please be cautious not to call <code>clReleaseMemObj</code> on a <code>cl_mem</code> when ArrayFire might be using it!\r\n\r\nThe eight steps above are best illustrated using a fully-worked example. Below we use the OpenCL 2.0 C++ API and omit error checking to keep the code readable.\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">#include &lt;CL/cl2.hpp&gt;\r\n \r\n// 1. Add arrayfire.h and af/opencl.h to your application\r\n#include \"arrayfire.h\"\r\n#include \"af/opencl.h\"\r\n \r\n#include &lt;cstdio&gt;\r\n#include &lt;vector&gt;\r\n \r\nint main() {\r\n \r\n// Set up the OpenCL context, device, and queues\r\ncl::Context context(CL_DEVICE_TYPE_ALL);\r\nvector&lt;cl::Device&gt; devices = context.getInfo&lt;CL_CONTEXT_DEVICES&gt;();\r\ncl::Device device = devices[0];\r\ncl::CommandQueue queue(context, device);\r\n \r\n// Create a buffer of size 10 filled with ones, copy it to the device\r\nint length = 10;\r\nvector&lt;float&gt; h_A(length, 1);\r\ncl::Buffer cl_A(context, CL_MEM_READ_WRITE, length * sizeof(float), h_A.data());\r\n \r\n// 2. Instruct OpenCL to complete its operations using clFinish (or similar)\r\nqueue.finish();\r\n \r\n// 3. Instruct ArrayFire to use the user-created context\r\n// First, create a device from the current OpenCL device + context + queue\r\nafcl::addDevice(device(), context(), queue());\r\n// Next switch ArrayFire to the device using the device and context as\r\n// identifiers:\r\nafcl::setDevice(device(), context());\r\n \r\n// 4. Create ArrayFire arrays from OpenCL memory objects\r\naf::array af_A = afcl::array(length, cl_A(), f32, true);\r\n \r\n// 5. Perform ArrayFire operations on the Arrays\r\naf_A = af_A + af::randu(length);\r\n \r\n// NOTE: ArrayFire does not perform the above transaction using in-place memory,\r\n// thus the underlying OpenCL buffers containing the memory containing memory to\r\n// probably have changed\r\n \r\n// 6. Instruct ArrayFire to finish operations using af::sync\r\naf::sync();\r\n \r\n// 7. Obtain cl_mem references for important memory\r\ncl_A = *af_A.device&lt;cl_mem&gt;();\r\n \r\n// 8. Continue your OpenCL application\r\n \r\n// ...\r\n \r\nreturn 0;\r\n}</pre>\r\n</div>\r\n</div>\r\n<h4>Using multiple devices</h4>\r\nIf you are using ArrayFire and OpenCL with multiple devices be sure to use <code>afcl::addDevice</code> to add your custom context + device + queue to ArrayFire\'s device manager. This will let you switch ArrayFire devices using your current<code>cl_device_id</code> and <code>cl_context</code>.','ArrayFire - OpenCL Interoperability','','inherit','closed','closed','','8874-revision-v1','','','2016-12-20 14:33:04','2016-12-20 19:33:04','',8874,'http://sandbox.arrayfire.com/8874-revision-v1/',0,'revision','',0),(9424,18672,'2016-12-22 11:26:51','2016-12-22 16:26:51','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/windows-installer\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\"  shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-x86_64-installer\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\"  shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/osx-installer\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\"  shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\"  type=\"flat\"  shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-armv7l-installer\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2016-12-22 11:26:51','2016-12-22 16:26:51','',5931,'http://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9426,18672,'2016-12-29 14:06:48','2016-12-29 19:06:48','Here at ArrayFire, we develop code that will work efficiently on both CUDA and OpenCL platforms. Therefore, it is not uncommon that CUDA code on NVIDIA GPUs will run faster than OpenCL. A very good way to understand what is behind the curtains is to generate the PTX file for both cases and compare them. In this post, we show how to generate PTX for both CUDA and OpenCL kernels.\r\n\r\nPTX stands for <a title=\"Parallel Thread eXecution\" href=\"http://docs.nvidia.com/cuda/parallel-thread-execution\">Parallel Thread eXecution</a>, which is a low-level virtual machine and instruction set architecture (ISA). For those familiar with assembly language, the PTX instruction set is not really more complicated than a single thread assembly code, except that now we are thinking in massive parallel execution.\r\n\r\nRetrieving the PTX file from a CUDA kernel is a pretty straightforward process. First, we need a CUDA kernel, we will use the following code for this article, a simple vector addition kernel.\r\n<pre>__global__ void add_vectors(\r\n    const float* a,\r\n    const float* b,\r\n    float *c,\r\n    const int n)\r\n{\r\n    const int idx = blockIdx.x * blockDim.x + threadIdx.x;\r\n\r\n    if (idx <= n) return;\r\n\r\n    c[idx] = a[idx] + b[idx];\r\n}\r\n</pre>\r\nFor simplicity assume that this function is saved to  <code>add_vectors.cu.</code> Now we simply call the NVCC compiler with the <code>--ptx</code> argument.\r\n<pre>nvcc --ptx add_vectors.cu\r\n</pre>\r\nThe compiler output is a text file named <code>add_vectors.ptx</code>.\r\n\r\nRetrieving the PTX file for an OpenCL file is somewhat more challenging. Those of you familiar with OpenCL are probably not surprised. Retrieving the PTX code requires host-side code and the OpenCL file which is only extracted at runtime. This means that the host-side code is necessary for compilation of the OpenCL function whereas this was not necessary for the CUDA code.\r\n\r\nThe OpenCL kernel will be very similar to the CUDA kernel and can be saved with any name, here we will use <code>add_vectors.cl</code>, just be aware of the file name to pass the correct one to the host-side code. Below the vector addition kernel adapted to OpenCL is provided.\r\n<pre>__kernel void add_vectors(\r\n    __global const int* a,\r\n    __global const int* b,\r\n    __global       int* c,\r\n    int n)\r\n{\r\n    int idx = get_global_id(0);\r\n\r\n    if (idx <= n) return;\r\n\r\n    c[idx] = a[idx] + b[idx];\r\n}\r\n</pre>\r\nFinally, we need the host-side code. A minimalist version (without actually executing the OpenCL kernel) follows.\r\n<pre>#include \r\n#include \r\n\r\n#ifdef __APPLE__\r\n#include <OpenCL/opencl.h>\r\n#else\r\n#include <CL/cl.h>\r\n#endif\r\n\r\nint main(int argc, char* argv[])\r\n{\r\n    // Loads add_vectors.cl\r\n    FILE* fp;\r\n    fp = fopen(\"add_vectors.cl\", \"r\");\r\n    if (!fp) {\r\n        fprintf(stderr, \"Error loading kernel.\\n\");\r\n        exit(1);\r\n    }\r\n\r\n    fseek(fp, 0, SEEK_END);\r\n    size_t kernel_sz = ftell(fp);\r\n    rewind(fp);\r\n\r\n    char* kernel_str = (char*)malloc(kernel_sz);\r\n    fread(kernel_str, 1, kernel_sz, fp);\r\n    fclose(fp);\r\n\r\n    // Query platforms and devices\r\n    cl_platform_id platform;\r\n    cl_device_id device;\r\n    cl_uint num_devices, num_platforms;\r\n    cl_int err = clGetPlatformIDs(1, &platform, &num_platforms);\r\n    err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, 1,\r\n                         &device, &num_devices);\r\n\r\n    // Create OpenCL context\r\n    cl_context context = clCreateContext(NULL, 1, &device, NULL, NULL, &err);\r\n\r\n    // Create OpenCL command queue\r\n    cl_command_queue command_queue = clCreateCommandQueue(context, device, 0, &err);\r\n\r\n    // Create OpenCL program for add_vectors.cl\r\n    cl_program program = clCreateProgramWithSource(context, 1,\r\n            (const char **)&kernel_str, (const size_t *)&kernel_sz, &err);\r\n\r\n    // Build OpenCL program\r\n    err = clBuildProgram(program, 1, &device, NULL, NULL, NULL);\r\n\r\n    // Create OpenCL kernel\r\n    cl_kernel kernel = clCreateKernel(program, \"add_vectors\", &err);\r\n\r\n    // Query binary (PTX file) size\r\n    size_t bin_sz;\r\n    err = clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES, sizeof(size_t), &bin_sz, NULL);\r\n\r\n    // Read binary (PTX file) to memory buffer\r\n    unsigned char *bin = (unsigned char *)malloc(bin_sz);\r\n    err = clGetProgramInfo(program, CL_PROGRAM_BINARIES, sizeof(unsigned char *), &bin, NULL);\r\n\r\n    // Save PTX to add_vectors_ocl.ptx\r\n    fp = fopen(\"add_vectors_ocl.ptx\", \"wb\");\r\n    fwrite(bin, sizeof(char), bin_sz, fp);\r\n    fclose(fp);\r\n    free(bin);\r\n\r\n    // Release OpenCL resources\r\n    clFlush(command_queue);\r\n    clFinish(command_queue);\r\n    clReleaseKernel(kernel);\r\n    clReleaseProgram(program);\r\n    clReleaseCommandQueue(command_queue);\r\n    clReleaseContext(context);\r\n    return 0;\r\n}\r\n</pre>\r\nTo compile the code above with GCC, it is necessary only to pass the OpenCL include files to the compiler and the OpenCL library to the linker. The code should also compile under Visual Studio with little or no changes.\r\n<pre>gcc -Wall -g add_vectors.c -o add_vectors -I/usr/local/cuda/include -lOpenCL\r\n</pre>\r\nFinally, the code can be executed and the PTX will be saved to the file <code>add_vectors_ocl.ptx</code>. Note that for this simple example the PTX will only be extracted if the device 0 is an NVIDIA device, otherwise, it will not be a PTX file.\r\n\r\nIf you think the host-side code is too long and complicated, don\'t worry, check the <a href=\"http://sandbox.arrayfire.com/quest-for-the-smallest-opencl-program/\">Quest for the Smallest OpenCL Program</a>. One of our engineers wrote a blog that uses the C++ API of OpenCL and he explains how to write simple and short OpenCL code. With few changes, it is possible to use the short C++ code to extract the PTX file from OpenCL kernels.\r\n\r\nThe complete code along with Makefile and instructions to build it can be found <a href=\"https://github.com/pentschev/ptxtract\">here</a>.\r\n\r\nWe plan on following up this blog and discuss in more depth analyzing PTX for both CUDA and OpenCL kernels, altogether with a more general host-side code. We will introduce some simple but interesting methods that we use that help us understand and improve code performance. So stay in touch!','Generating PTX files from OpenCL code','','inherit','closed','closed','','6495-revision-v1','','','2016-12-29 14:06:48','2016-12-29 19:06:48','',6495,'http://sandbox.arrayfire.com/6495-revision-v1/',0,'revision','',0),(9427,18672,'2016-12-29 19:24:22','2016-12-30 00:24:22','The ArrayFire library attempts to make high-performance computing as easy as possible for scientists and engineers. Because many tasks need to be visualized, ArrayFire also provides a high-level interface to our <a href=\"https://github.com/arrayfire/forge\">Forge visualization library</a>. In today\'s \"<a href=\"http://sandbox.arrayfire.com/tag/learning-arrayfire-from-scratch/\">Learning ArrayFire from scratch</a>\" post we present an overview of ArrayFire\'s visualization functionality and demonstrate how to use Forge to display data contained in af::array objects.\n\n<!--more-->\n\nThe Forge library is a general-purpose visualization tool for data stored on the GPU or related accelerator devices. By default, ArrayFire ships with Forge built in. However; if you or your system administrator installed the \"no-graphics\" version of ArrayFire, Forge won\'t be included.\n\nArrayFire provides several wrapper functions that simplify Forge\'s interface when used with <a class=\"el\" title=\"A multi dimensional data container. \" href=\"classaf_1_1array.htm\">af::array</a> objects. These functions primarily perform interop tasks including visualization range setting, copying data into OpenGL data structures, and generating an OpenGL window for display.\n<h4><a id=\"setup\" class=\"anchor\"></a>Setup</h4>\nBefore we can use Forge, we must create an window containing an OpenGL context. Creating an instance of the<code><a class=\"el\" title=\"Window object to render af::arrays. \" href=\"classaf_1_1Window.htm\">af::Window</a></code> class will accomplish both of these tasks. Note, at present Forge must create and manage its own OpenGL context; however, we hope to change this in a future release. Once the window is created, you can use Forge\'s drawing functions to visualize your data. Here is a basic example of how to create a window, set its title, and enter into a drawing loop:\n<div class=\"fragment\">\n<div class=\"line\">\n<pre class=\"lang:default decode:true \">const static int width = 512, height = 512;\naf::Window window(width, height, \"2D plot example title\");\n \ndo{\n \n//drawing functions here\n \n} while( !window.close() );</pre>\n</div>\n</div>\n<h4><a id=\"render_func\" class=\"anchor\"></a>Rendering Functions</h4>\nAs included in ArrayFire 3.3, Forge provides the following plotting capabilities:\n<table class=\"doxtable\">\n<tbody>\n<tr>\n<th>Function</th>\n<th>Description</th>\n</tr>\n<tr>\n<td><a class=\"el\" title=\"Renders the input array as a histogram to the window. \" href=\"group__gfx__func__draw.htm#gafd7d94aa8f5fd37fee0662a4906a38d7\">af::Window::hist()</a></td>\n<td>Creates a histogram plot from input data and bins</td>\n</tr>\n<tr>\n<td><a class=\"el\" title=\"Renders the input array as an image to the window. \" href=\"group__gfx__func__draw.htm#gaed174450be6db4dfa5ef65b7baccbe57\">af::Window::image()</a></td>\n<td>Display an image</td>\n</tr>\n<tr>\n<td><a class=\"el\" title=\"Renders the input arrays as a 2D plot to the window. \" href=\"group__gfx__func__draw.htm#ga8e01736df3d805a5488c609e2573818b\">af::Window::plot()</a></td>\n<td>2D Line plot</td>\n</tr>\n<tr>\n<td><a class=\"el\" title=\"Renders the input array as an 3d line plot to the window. \" href=\"group__gfx__func__draw.htm#ga8e04ec129034e9fe769f3e6b14cd087f\">af::Window::plot3()</a></td>\n<td>3D line plot</td>\n</tr>\n<tr>\n<td><a class=\"el\" title=\"Renders the input arrays as a 2D scatter-plot to the window. \" href=\"group__gfx__func__draw.htm#ga73406db589e5090c051baae0af175df9\">af::Window::scatter()</a></td>\n<td>2D scatter plot</td>\n</tr>\n<tr>\n<td><a class=\"el\" title=\"Renders the input arrays as a 3D scatter-plot to the window. \" href=\"group__gfx__func__draw.htm#ga3bbfbe1b60741a259d2146b3ab50ace3\">af::Window::scatter3()</a></td>\n<td>3D scatter plot</td>\n</tr>\n<tr>\n<td><a class=\"el\" title=\"Renders the input arrays as a 3D surface plot to the window. \" href=\"group__gfx__func__draw.htm#ga1cdb8c3205d70d8feaddd8c30245393f\">af::Window::surface()</a></td>\n<td>Visualize a 3D surface</td>\n</tr>\n</tbody>\n</table>\nFull documentation on all plotting functions can be found in the <a class=\"el\" href=\"group__gfx__func__draw.htm\">rendering functions</a> portion of the documentation.\n<h5><a id=\"Image_38\"></a>Image</h5>\nThe af::Window::image() function can be used to plot grayscale or color images. To plot a grayscale image a 2d array should be passed into the function.\nLet’s see this on a static noise example:\n<pre><code class=\"language-{.cpp}\">array img = constant(0, width, height);   //make a black image\narray random = randu(width, height);      //make random [0,1] distribution\n\nwindow.image(img);</code></pre>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/noise.png\"><img class=\"aligncenter size-medium wp-image-8710\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/noise-262x300.png\" alt=\"Forge image plot of noise\" width=\"262\" height=\"300\" /></a>\n\nTweaking the previous example by giving our image a depth of 3 for the RGB values allows us to generate colorful noise:\n<pre><code class=\"language-{.cpp}\">array img = 255 * randu(width, height, 3);      //make random [0, 255] distribution\nwindow.image( img.as(u8) );</code></pre>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/color_noise.png\"><img class=\"aligncenter size-medium wp-image-8708\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/color_noise-262x300.png\" alt=\"Forge image plot of color noise\" width=\"262\" height=\"300\" /></a>\n\nNote that Forge automatically handles any af::array type passed from Arrayfire. In the first example we passed in an image of floats in the range [0, 1]. In the last example we cast our array to an unsigned byte array with the range\n[0, 255]. The type-handling properties are consistent for all Forge drawing functions.\n<h5><a id=\"Plot_63\"></a>Plot</h5>\nThe af::Window::plot() function visualizes an array as a 2d-line plot. Let’s see a simple example:\n<pre><code class=\"language-{.cpp}\">array X = seq(-af::Pi, af::Pi, 0.01);\narray Y = sin(X);\nwindow.plot(X, Y);</code></pre>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/sin_plot.png\"><img class=\"aligncenter size-medium wp-image-8714\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/sin_plot-296x300.png\" alt=\"Forge 2d line plot of sin() function\" width=\"296\" height=\"300\" /></a>\nThe plot function has the signature:\n\n<code><strong>void plot( const array &amp;X, const array &amp;Y, const char * const title = NULL );</strong></code>\n\nBoth the x and y coordinates of the points are required to plot. This allows for non-uniform, or parametric plots:\n<pre><code class=\"language-{.cpp}\">array t = seq(0, 100, 0.01);\narray X = sin(t) * (exp(cos(t)) - 2 * cos(4 * t) - pow(sin(t / 12), 5));\narray Y = cos(t) * (exp(cos(t)) - 2 * cos(4 * t) - pow(sin(t / 12), 5));\nwindow.plot(X, Y);</code></pre>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/butterfly_plot.png\"><img class=\"aligncenter size-medium wp-image-8707\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/butterfly_plot-290x300.png\" alt=\"\" width=\"290\" height=\"300\" /></a>\n<h5><a id=\"Scatter_88\"></a>Scatter</h5>\nThe af::Window::scatter() function visualizes an array as a 2d-scatter plot. Let’s see a example:\n<pre><code class=\"language-{.cpp}\">array X = seq(-af::Pi, af::Pi, 0.01);\narray noise = randn(X.dims(0)) /3.0f;\narray Y = sin(X) + noise;\nwindow.scatter(X, Y);</code></pre>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/sin_scatter.png\"><img class=\"aligncenter size-medium wp-image-8715\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/sin_scatter-300x228.png\" alt=\"Forge 2d scatter plot\" width=\"300\" height=\"228\" /></a>\n\nThe scatter function has the signature:\n\n<code><strong>void scatter( const array &amp;X, const array &amp;Y, af::markerType marker=AF_MARKER_POINT, const char * const title = NULL);</strong></code>\n\nThe <strong>af::markerType</strong> enum determines which marker will be drawn at each point.\nIt can take on the values of:\n<pre><code class=\"language-{.cpp}\">enum af::markerType {\n    AF_MARKER_POINT\n    AF_MARKER_CIRCLE\n    AF_MARKER_SQUARE\n    AF_MARKER_TRIANGLE\n    AF_MARKER_CROSS\n    AF_MARKER_PLUS\n    AF_MARKER_STAR\n};</code></pre>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/marker_types.png\"><img class=\"aligncenter size-full wp-image-8709\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/marker_types.png\" alt=\"Different types of markers in Forge.\" width=\"1846\" height=\"326\" /></a>\n<h5><a id=\"Plot3_118\"></a>Plot3</h5>\nThe af::Window::plot3() function will plot a curve in 3d-space.\nIts signature is:\n\n<code><strong>void plot3 (const array &amp;in, const char * title = NULL);</strong></code>\n\nThe input array expects xyz-triplets in sequential order. The points can be in a flattened one dimensional (<em>3n x 1</em>) array, or in one of the (<em>3 x n</em>), (<em>n x 3</em>) matrix forms.\n<pre><code class=\"language-{.cpp}\">array Z = seq(0.1f, 10.f, 0.01);\narray Y = sin(10 * Z) / Z;\narray X = cos(10 * Z) / Z;\n\narray Pts = join(1, X, Y, Z);\n//Pts can be passed in as a matrix in the from n x 3, 3 x n\n//or in the flattened xyz-triplet array with size 3n x 1\nwindow.plot3(Pts);\n//both of the following are equally valid\n//window.plot3(transpose(Pts));\n//window.plot3(flat(Pts));</code></pre>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/spiral_plot3.png\"><img class=\"aligncenter size-medium wp-image-8716\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/spiral_plot3-300x211.png\" alt=\"Forge 3d line plot\" width=\"300\" height=\"211\" /></a>\n<h5><a id=\"Histogram_140\"></a>Histogram</h5>\nThe af::Window::hist() function renders an input array as a histogram. In our example, the input array will be created with Arrayfire’s histogram() function, which actually counts and bins each sample. The output from histogram() can directly be fed into the af::Window::hist() rendering function.\n<pre><code class=\"language-{.cpp}\">const int BINS = 128; SAMPLES = 9162;\narray norm = randn(SAMPLES);\narray hist_arr = histogram(norm, BINS);\n\nwin.hist(hist_arr, 0, BINS);</code></pre>\nIn addition to the histogram array with the number of samples in each bin, the af::Window::hist() function takes two additional parameters – the minimum and maximum values of all datapoints in the histogram array. This effectively sets the range of the binned data. The full signature of af::Window::hist() is:\n\n<code><strong>void hist(const array &amp; X, const double minval, const double maxval, const char * const title = NULL);</strong></code>\n\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/norm_histogram.png\"><img class=\"aligncenter size-medium wp-image-8711\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/norm_histogram-300x256.png\" alt=\"Forge histogram plot\" width=\"300\" height=\"256\" /></a>\n<h5><a id=\"Scatter3_162\"></a>Scatter3</h5>\nThe af::Window::scatter3() function visualizes an array as a 3d-scatter plot.\nIts signature is:\n\n<code><strong>void scatter3 (const array &amp;in, af::markerType marker=AF_MARKER_POINT, const char * title = NULL);</strong></code>\n\nThe input array expects xyz-triplets in sequential order. The points can be in a flattened one dimensional (<em>3n x 1</em>) array, or in one of the (<em>3 x n</em>), (<em>n x 3</em>) matrix forms.\n\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/norm_scatter3.png\"><img class=\"aligncenter size-medium wp-image-8712\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/norm_scatter3-300x208.png\" alt=\"Forge 3d scatter plot\" width=\"300\" height=\"208\" /></a>\n<pre><code class=\"language-{.cpp}\">array X = randn(300);\narray Y = randn(300);\narray Z = randn(300);\n\narray Pts = join(1, X, Y, Z);\nwindow.scatter3(Pts);</code></pre>\nThe <strong>af::markerType</strong> enum determines which marker will be drawn at each point. It can take on the values of:\n<pre><code class=\"language-{.cpp}\">enum af::markerType {\n    AF_MARKER_POINT\n    AF_MARKER_CIRCLE\n    AF_MARKER_SQUARE\n    AF_MARKER_TRIANGLE\n    AF_MARKER_CROSS\n    AF_MARKER_PLUS\n    AF_MARKER_STAR\n};</code></pre>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/marker_types.png\"><img class=\"aligncenter size-full wp-image-8709\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/marker_types.png\" alt=\"Different types of markers in Forge.\" width=\"1846\" height=\"326\" /></a>\n<h5><a id=\"Surface_195\"></a>Surface</h5>\nThe af::Window::surface() function will plot af::arrays as a 3d surface.\n<pre><code class=\"language-{.cpp}\">array Z = randu(21, 21);\nwindow.surface(Z, \"Random Surface\");    //equal to next function call\n//window.surface( seq(-1, 1, 0.1), seq(-1, 1, 0.1), Z, \"Random Surface\");</code></pre>\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/rand_surface.png\"><img class=\"aligncenter size-medium wp-image-8713\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/rand_surface-300x269.png\" alt=\"Forge 3d surface() plot\" width=\"300\" height=\"269\" /></a>\nThere are two overloads for the af::Window::surface() function:\n\n<code><strong>void surface (const array &amp; S, const char * const title )</strong>\n// Accepts a 2d matrix with the z values of the surface</code>\n\n<code><strong>void surface (const array &amp;xVals, const array &amp;yVals, const array &amp;S, const char * const title)</strong>\n// accepts additional vectors that define the x,y coordinates for the surface points.</code>\n\nThe second overload has two options for the x, y coordinate vectors. Assuming a surface grid of size <strong>m x n</strong>:\n<ol>\n 	<li>Short vectors defining the spacing along each axis. Vectors will have sizes <strong>m x 1</strong> and <strong>n x 1</strong>.</li>\n 	<li>Vectors containing the coordinates of each and every point. Each of the vectors will have length <strong>mn x 1</strong>. This can be used for completely non-uniform or parametric surfaces.</li>\n</ol>\n<h4><a id=\"Conclusion_216\"></a>Conclusion</h4>\nThere is a fairly comprehensive collection of methods to visualize data in Arrayfire. Thanks to the high-performance gpu plotting library Forge, the provided Arrayfire functions not only make visualizations as simple as possible, but keep them as robust as the rest of the Arrayfire library.','Visualizing the af::array with Forge','','inherit','closed','closed','','8698-autosave-v1','','','2016-12-29 19:24:22','2016-12-30 00:24:22','',8698,'http://sandbox.arrayfire.com/8698-autosave-v1/',0,'revision','',0),(9428,18672,'2016-12-29 19:24:43','2016-12-30 00:24:43','The ArrayFire library attempts to make high-performance computing as easy as possible for scientists and engineers. Because many tasks need to be visualized, ArrayFire also provides a high-level interface to our <a href=\"https://github.com/arrayfire/forge\">Forge visualization library</a>. In today\'s \"<a href=\"http://sandbox.arrayfire.com/tag/learning-arrayfire-from-scratch/\">Learning ArrayFire from scratch</a>\" post we present an overview of ArrayFire\'s visualization functionality and demonstrate how to use Forge to display data contained in af::array objects.\r\n\r\n<!--more-->\r\n\r\nThe Forge library is a general-purpose visualization tool for data stored on the GPU or related accelerator devices. By default, ArrayFire ships with Forge built in. However; if you or your system administrator installed the \"no-graphics\" version of ArrayFire, Forge won\'t be included.\r\n\r\nArrayFire provides several wrapper functions that simplify Forge\'s interface when used with <a class=\"el\" title=\"A multi dimensional data container. \" href=\"classaf_1_1array.htm\">af::array</a> objects. These functions primarily perform interop tasks including visualization range setting, copying data into OpenGL data structures, and generating an OpenGL window for display.\r\n<h4><a id=\"setup\" class=\"anchor\"></a>Setup</h4>\r\nBefore we can use Forge, we must create an window containing an OpenGL context. Creating an instance of the<code><a class=\"el\" title=\"Window object to render af::arrays. \" href=\"classaf_1_1Window.htm\">af::Window</a></code> class will accomplish both of these tasks. Note, at present Forge must create and manage its own OpenGL context; however, we hope to change this in a future release. Once the window is created, you can use Forge\'s drawing functions to visualize your data. Here is a basic example of how to create a window, set its title, and enter into a drawing loop:\r\n<div class=\"fragment\">\r\n<div class=\"line\">\r\n<pre class=\"lang:default decode:true \">const static int width = 512, height = 512;\r\naf::Window window(width, height, \"2D plot example title\");\r\n \r\ndo{\r\n \r\n//drawing functions here\r\n \r\n} while( !window.close() );</pre>\r\n</div>\r\n</div>\r\n<h4><a id=\"render_func\" class=\"anchor\"></a>Rendering Functions</h4>\r\nAs included in ArrayFire 3.3, Forge provides the following plotting capabilities:\r\n<table class=\"doxtable\">\r\n<tbody>\r\n<tr>\r\n<th>Function</th>\r\n<th>Description</th>\r\n</tr>\r\n<tr>\r\n<td><a class=\"el\" title=\"Renders the input array as a histogram to the window. \" href=\"group__gfx__func__draw.htm#gafd7d94aa8f5fd37fee0662a4906a38d7\">af::Window::hist()</a></td>\r\n<td>Creates a histogram plot from input data and bins</td>\r\n</tr>\r\n<tr>\r\n<td><a class=\"el\" title=\"Renders the input array as an image to the window. \" href=\"group__gfx__func__draw.htm#gaed174450be6db4dfa5ef65b7baccbe57\">af::Window::image()</a></td>\r\n<td>Display an image</td>\r\n</tr>\r\n<tr>\r\n<td><a class=\"el\" title=\"Renders the input arrays as a 2D plot to the window. \" href=\"group__gfx__func__draw.htm#ga8e01736df3d805a5488c609e2573818b\">af::Window::plot()</a></td>\r\n<td>2D Line plot</td>\r\n</tr>\r\n<tr>\r\n<td><a class=\"el\" title=\"Renders the input array as an 3d line plot to the window. \" href=\"group__gfx__func__draw.htm#ga8e04ec129034e9fe769f3e6b14cd087f\">af::Window::plot3()</a></td>\r\n<td>3D line plot</td>\r\n</tr>\r\n<tr>\r\n<td><a class=\"el\" title=\"Renders the input arrays as a 2D scatter-plot to the window. \" href=\"group__gfx__func__draw.htm#ga73406db589e5090c051baae0af175df9\">af::Window::scatter()</a></td>\r\n<td>2D scatter plot</td>\r\n</tr>\r\n<tr>\r\n<td><a class=\"el\" title=\"Renders the input arrays as a 3D scatter-plot to the window. \" href=\"group__gfx__func__draw.htm#ga3bbfbe1b60741a259d2146b3ab50ace3\">af::Window::scatter3()</a></td>\r\n<td>3D scatter plot</td>\r\n</tr>\r\n<tr>\r\n<td><a class=\"el\" title=\"Renders the input arrays as a 3D surface plot to the window. \" href=\"group__gfx__func__draw.htm#ga1cdb8c3205d70d8feaddd8c30245393f\">af::Window::surface()</a></td>\r\n<td>Visualize a 3D surface</td>\r\n</tr>\r\n</tbody>\r\n</table>\r\nFull documentation on all plotting functions can be found in the <a class=\"el\" href=\"group__gfx__func__draw.htm\">rendering functions</a> portion of the documentation.\r\n<h5><a id=\"Image_38\"></a>Image</h5>\r\nThe af::Window::image() function can be used to plot grayscale or color images. To plot a grayscale image a 2d array should be passed into the function.\r\nLet’s see this on a static noise example:\r\n<pre><code class=\"language-{.cpp}\">array img = constant(0, width, height);   //make a black image\r\narray random = randu(width, height);      //make random [0,1] distribution\r\n\r\nwindow.image(img);</code></pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/noise.png\"><img class=\"aligncenter size-medium wp-image-8710\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/noise-262x300.png\" alt=\"Forge image plot of noise\" width=\"262\" height=\"300\" /></a>\r\n\r\nTweaking the previous example by giving our image a depth of 3 for the RGB values allows us to generate colorful noise:\r\n<pre><code class=\"language-{.cpp}\">array img = 255 * randu(width, height, 3);      //make random [0, 255] distribution\r\nwindow.image( img.as(u8) );</code></pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/color_noise.png\"><img class=\"aligncenter size-medium wp-image-8708\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/color_noise-262x300.png\" alt=\"Forge image plot of color noise\" width=\"262\" height=\"300\" /></a>\r\n\r\nNote that Forge automatically handles any af::array type passed from Arrayfire. In the first example we passed in an image of floats in the range [0, 1]. In the last example we cast our array to an unsigned byte array with the range\r\n[0, 255]. The type-handling properties are consistent for all Forge drawing functions.\r\n<h5><a id=\"Plot_63\"></a>Plot</h5>\r\nThe af::Window::plot() function visualizes an array as a 2d-line plot. Let’s see a simple example:\r\n<pre><code class=\"language-{.cpp}\">array X = seq(-af::Pi, af::Pi, 0.01);\r\narray Y = sin(X);\r\nwindow.plot(X, Y);</code></pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/sin_plot.png\"><img class=\"aligncenter size-medium wp-image-8714\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/sin_plot-296x300.png\" alt=\"Forge 2d line plot of sin() function\" width=\"296\" height=\"300\" /></a>\r\nThe plot function has the signature:\r\n\r\n<code><strong>void plot( const array &amp;X, const array &amp;Y, const char * const title = NULL );</strong></code>\r\n\r\nBoth the x and y coordinates of the points are required to plot. This allows for non-uniform, or parametric plots:\r\n<pre><code class=\"language-{.cpp}\">array t = seq(0, 100, 0.01);\r\narray X = sin(t) * (exp(cos(t)) - 2 * cos(4 * t) - pow(sin(t / 12), 5));\r\narray Y = cos(t) * (exp(cos(t)) - 2 * cos(4 * t) - pow(sin(t / 12), 5));\r\nwindow.plot(X, Y);</code></pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/butterfly_plot.png\"><img class=\"aligncenter size-medium wp-image-8707\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/butterfly_plot-290x300.png\" alt=\"\" width=\"290\" height=\"300\" /></a>\r\n<h5><a id=\"Scatter_88\"></a>Scatter</h5>\r\nThe af::Window::scatter() function visualizes an array as a 2d-scatter plot. Let’s see a example:\r\n<pre><code class=\"language-{.cpp}\">array X = seq(-af::Pi, af::Pi, 0.01);\r\narray noise = randn(X.dims(0)) /3.0f;\r\narray Y = sin(X) + noise;\r\nwindow.scatter(X, Y);</code></pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/sin_scatter.png\"><img class=\"aligncenter size-medium wp-image-8715\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/sin_scatter-300x228.png\" alt=\"Forge 2d scatter plot\" width=\"300\" height=\"228\" /></a>\r\n\r\nThe scatter function has the signature:\r\n\r\n<code><strong>void scatter( const array &amp;X, const array &amp;Y, af::markerType marker=AF_MARKER_POINT, const char * const title = NULL);</strong></code>\r\n\r\nThe <strong>af::markerType</strong> enum determines which marker will be drawn at each point.\r\nIt can take on the values of:\r\n<pre><code class=\"language-{.cpp}\">enum af::markerType {\r\n    AF_MARKER_POINT\r\n    AF_MARKER_CIRCLE\r\n    AF_MARKER_SQUARE\r\n    AF_MARKER_TRIANGLE\r\n    AF_MARKER_CROSS\r\n    AF_MARKER_PLUS\r\n    AF_MARKER_STAR\r\n};</code></pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/marker_types.png\"><img class=\"aligncenter size-full wp-image-8709\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/marker_types.png\" alt=\"Different types of markers in Forge.\" width=\"1846\" height=\"326\" /></a>\r\n<h5><a id=\"Plot3_118\"></a>Plot3</h5>\r\nThe af::Window::plot3() function will plot a curve in 3d-space.\r\nIts signature is:\r\n\r\n<code><strong>void plot3 (const array &amp;in, const char * title = NULL);</strong></code>\r\n\r\nThe input array expects xyz-triplets in sequential order. The points can be in a flattened one dimensional (<em>3n x 1</em>) array, or in one of the (<em>3 x n</em>), (<em>n x 3</em>) matrix forms.\r\n<pre><code class=\"language-{.cpp}\">array Z = seq(0.1f, 10.f, 0.01);\r\narray Y = sin(10 * Z) / Z;\r\narray X = cos(10 * Z) / Z;\r\n\r\narray Pts = join(1, X, Y, Z);\r\n//Pts can be passed in as a matrix in the from n x 3, 3 x n\r\n//or in the flattened xyz-triplet array with size 3n x 1\r\nwindow.plot3(Pts);\r\n//both of the following are equally valid\r\n//window.plot3(transpose(Pts));\r\n//window.plot3(flat(Pts));</code></pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/spiral_plot3.png\"><img class=\"aligncenter size-medium wp-image-8716\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/spiral_plot3-300x211.png\" alt=\"Forge 3d line plot\" width=\"300\" height=\"211\" /></a>\r\n<h5><a id=\"Histogram_140\"></a>Histogram</h5>\r\nThe af::Window::hist() function renders an input array as a histogram. In our example, the input array will be created with Arrayfire’s histogram() function, which actually counts and bins each sample. The output from histogram() can directly be fed into the af::Window::hist() rendering function.\r\n<pre><code class=\"language-{.cpp}\">const int BINS = 128; SAMPLES = 9162;\r\narray norm = randn(SAMPLES);\r\narray hist_arr = histogram(norm, BINS);\r\n\r\nwin.hist(hist_arr, 0, BINS);</code></pre>\r\nIn addition to the histogram array with the number of samples in each bin, the af::Window::hist() function takes two additional parameters – the minimum and maximum values of all datapoints in the histogram array. This effectively sets the range of the binned data. The full signature of af::Window::hist() is:\r\n\r\n<code><strong>void hist(const array &amp; X, const double minval, const double maxval, const char * const title = NULL);</strong></code>\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/norm_histogram.png\"><img class=\"aligncenter size-medium wp-image-8711\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/norm_histogram-300x256.png\" alt=\"Forge histogram plot\" width=\"300\" height=\"256\" /></a>\r\n<h5><a id=\"Scatter3_162\"></a>Scatter3</h5>\r\nThe af::Window::scatter3() function visualizes an array as a 3d-scatter plot.\r\nIts signature is:\r\n\r\n<code><strong>void scatter3 (const array &amp;in, af::markerType marker=AF_MARKER_POINT, const char * title = NULL);</strong></code>\r\n\r\nThe input array expects xyz-triplets in sequential order. The points can be in a flattened one dimensional (<em>3n x 1</em>) array, or in one of the (<em>3 x n</em>), (<em>n x 3</em>) matrix forms.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/norm_scatter3.png\"><img class=\"aligncenter size-medium wp-image-8712\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/norm_scatter3-300x208.png\" alt=\"Forge 3d scatter plot\" width=\"300\" height=\"208\" /></a>\r\n<pre><code class=\"language-{.cpp}\">array X = randn(300);\r\narray Y = randn(300);\r\narray Z = randn(300);\r\n\r\narray Pts = join(1, X, Y, Z);\r\nwindow.scatter3(Pts);</code></pre>\r\nThe <strong>af::markerType</strong> enum determines which marker will be drawn at each point. It can take on the values of:\r\n<pre><code class=\"language-{.cpp}\">enum af::markerType {\r\n    AF_MARKER_POINT\r\n    AF_MARKER_CIRCLE\r\n    AF_MARKER_SQUARE\r\n    AF_MARKER_TRIANGLE\r\n    AF_MARKER_CROSS\r\n    AF_MARKER_PLUS\r\n    AF_MARKER_STAR\r\n};</code></pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/marker_types.png\"><img class=\"aligncenter size-full wp-image-8709\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/marker_types.png\" alt=\"Different types of markers in Forge.\" width=\"1846\" height=\"326\" /></a>\r\n<h5><a id=\"Surface_195\"></a>Surface</h5>\r\nThe af::Window::surface() function will plot af::arrays as a 3d surface.\r\n<pre><code class=\"language-{.cpp}\">array Z = randu(21, 21);\r\nwindow.surface(Z, \"Random Surface\");    //equal to next function call\r\n//window.surface( seq(-1, 1, 0.1), seq(-1, 1, 0.1), Z, \"Random Surface\");</code></pre>\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/rand_surface.png\"><img class=\"aligncenter size-medium wp-image-8713\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/12/rand_surface-300x269.png\" alt=\"Forge 3d surface() plot\" width=\"300\" height=\"269\" /></a>\r\nThere are two overloads for the af::Window::surface() function:\r\n\r\n<code><strong>void surface (const array &amp; S, const char * const title )</strong>\r\n// Accepts a 2d matrix with the z values of the surface</code>\r\n\r\n<code><strong>void surface (const array &amp;xVals, const array &amp;yVals, const array &amp;S, const char * const title)</strong>\r\n// accepts additional vectors that define the x,y coordinates for the surface points.</code>\r\n\r\nThe second overload has two options for the x, y coordinate vectors. Assuming a surface grid of size <strong>m x n</strong>:\r\n<ol>\r\n 	<li>Short vectors defining the spacing along each axis. Vectors will have sizes <strong>m x 1</strong> and <strong>n x 1</strong>.</li>\r\n 	<li>Vectors containing the coordinates of each and every point. Each of the vectors will have length <strong>mn x 1</strong>. This can be used for completely non-uniform or parametric surfaces.</li>\r\n</ol>\r\n<h4><a id=\"Conclusion_216\"></a>Conclusion</h4>\r\nThere is a fairly comprehensive collection of methods to visualize data in Arrayfire. Thanks to the high-performance gpu plotting library Forge, the provided Arrayfire functions not only make visualizations as simple as possible, but keep them as robust as the rest of the Arrayfire library.','Visualizing the af::array with Forge','','inherit','closed','closed','','8698-revision-v1','','','2016-12-29 19:24:43','2016-12-30 00:24:43','',8698,'http://sandbox.arrayfire.com/8698-revision-v1/',0,'revision','',0),(9430,17728,'2017-01-02 14:58:53','2017-01-02 19:58:53','We provide two methods for you to install the ArrayFire Library. You may either download pre-built installers or compile the library from source.\r\n<h4>Traditional Installation Method</h4>\r\nOur installers are pre-built packages for Windows, Mac OSX, and Linux. Here are a few benefits of the installers:\r\n<ul>\r\n 	<li>Fastest installation method for Windows, Mac, and Linux platforms</li>\r\n 	<li>Pre-configured with CPU, OpenCL, and CUDA backends</li>\r\n 	<li>Forge Visualization library built-in</li>\r\n 	<li>Includes Intel Math Kernel Library to accelerate CPU-bound tasks</li>\r\n</ul>\r\n[column type=\"one-half\"] [button block=\"true\" type=\"flat\"  shape=\"rounded\" href=\"http://sandbox.arrayfire.com/login/?redirect_to=http%3A%2F%2Farrayfire.com%2Fdownload\" size=\"regular\" ]Login to Download[/button] [/column]\r\n[column type=\"one-half\"]\r\n[button  block=\"true\" type=\"flat\"  shape=\"rounded\" href=\"http://www.sandbox.arrayfire.com/register?redirect_to=http%3A%2F%2Farrayfire.com%2Fdownload-wait\" size=\"regular\" ]Register[/button]\r\n[/column]\r\n\r\n[gap size=\"9%\"]\r\n<h4>Build from Source</h4>\r\nArrayFire\'s source code is distributed on GitHub where you can also find full build and installation instructions for Windows, Mac OSX, and Linux. Please be aware that an initial checkout and build of ArrayFire from source can take in excess of 40 minutes on modern quad-core processor.\r\n\r\n[button block=\"true\"  type=\"flat\"  shape=\"rounded\" href=\"https://github.com/arrayfire/arrayfire\" size=\"regular\" ]Download and Compile from Source[/button]','Download Splash','','inherit','closed','closed','','9008-autosave-v1','','','2017-01-02 14:58:53','2017-01-02 19:58:53','',9008,'https://sandbox.arrayfire.com/9008-autosave-v1/',0,'revision','',0),(9431,17728,'2017-01-02 14:59:40','2017-01-02 19:59:40','We provide two methods for you to install the ArrayFire Library. You may either download pre-built installers or compile the library from source.\r\n<h4>Traditional Installation Method</h4>\r\nOur installers are pre-built packages for Windows, Mac OSX, and Linux. Here are a few benefits of the installers:\r\n<ul>\r\n 	<li>Fastest installation method for Windows, Mac, and Linux platforms</li>\r\n 	<li>Pre-configured with CPU, OpenCL, and CUDA backends</li>\r\n 	<li>Forge Visualization library built-in</li>\r\n 	<li>Includes Intel Math Kernel Library to accelerate CPU-bound tasks</li>\r\n</ul>\r\n[column type=\"one-half\"] [button block=\"true\" type=\"flat\"  shape=\"rounded\" href=\"https://sandbox.arrayfire.com/login/?redirect_to=https%3A%2F%2Farrayfire.com%2Fdownload\" size=\"regular\" ]Login to Download[/button] [/column]\r\n[column type=\"one-half\"]\r\n[button  block=\"true\" type=\"flat\"  shape=\"rounded\" href=\"https://www.sandbox.arrayfire.com/register?redirect_to=https%3A%2F%2Farrayfire.com%2Fdownload-wait\" size=\"regular\" ]Register[/button]\r\n[/column]\r\n\r\n[gap size=\"9%\"]\r\n<h4>Build from Source</h4>\r\nArrayFire\'s source code is distributed on GitHub where you can also find full build and installation instructions for Windows, Mac OSX, and Linux. Please be aware that an initial checkout and build of ArrayFire from source can take in excess of 40 minutes on modern quad-core processor.\r\n\r\n[button block=\"true\"  type=\"flat\"  shape=\"rounded\" href=\"https://github.com/arrayfire/arrayfire\" size=\"regular\" ]Download and Compile from Source[/button]','Download Splash','','inherit','closed','closed','','9008-revision-v1','','','2017-01-02 14:59:40','2017-01-02 19:59:40','',9008,'https://sandbox.arrayfire.com/9008-revision-v1/',0,'revision','',0),(9432,17728,'2017-01-02 15:00:05','2017-01-02 20:00:05','Thank you for registering!  Please confirm your email by clicking the link in the email.\r\n\r\n[button block=\"true\" type=\"flat\"  shape=\"rounded\" href=\"https://sandbox.arrayfire.com/download\" size=\"regular\" ]Confirm your email, login, then click here to continue[/button]','Download Wait','','inherit','closed','closed','','9039-revision-v1','','','2017-01-02 15:00:05','2017-01-02 20:00:05','',9039,'https://sandbox.arrayfire.com/9039-revision-v1/',0,'revision','',0),(9433,17728,'2017-01-02 15:05:36','2017-01-02 20:05:36','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"10px\"][column type=\"two-fifths\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\"]If you want faster code, you\'ve come to the right place.[/custom_headline][gap size=\"3%\"][button  type=\"flat\" shape=\"rounded\" href=\"https://sandbox.arrayfire.com/download\" size=\"x-large\" block=\"true\"]Download ArrayFire[/button]\r\n\r\n[gap size=\"5%\"]\r\n\r\n[button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/consulting/\" size=\"x-large\" ]Schedule a consultation[/button][gap size=\"2%\"]\r\n\r\n[/column][column type=\"three-fifths\" last=\"true\"][gap size=\"7%\"]\r\n<div id=\"wistia_rj2bar3xxp\" class=\"wistia_embed\" style=\"width: 640px; height: 388px;\"></div>\r\n<script src=\"//fast.wistia.com/assets/external/E-v1.js\" charset=\"ISO-8859-1\"></script><script>// <![CDATA[\r\nwistiaEmbed = Wistia.embed(\"rj2bar3xxp\");\r\n// ]]></script>\r\n[/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]\r\n\r\n\r\n[content_band bg_color=\"#f2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\" class=\"center-text\"]Services[/custom_headline]\r\n\r\nArrayFire specializes in developing accelerated, scalable computing solutions on modern computational platforms for our clients. As an industry leader in high performance computing for nearly 10 years, ArrayFire continues to drive innovation in all areas of accelerated computing, ranging from apps deployed on low-powered and mobile platforms to scientific simulations on high-end supercomputers.\r\n\r\n[/content_band]\r\n\r\n[content_band bg_color=\"#ffffff\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"10px\"]\r\n\r\n[column type=\"one-third\" ][custom_headline type=\"left\" level=\"h3\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/car-e1412967813807.png\" class=\"mbn\"] Software Design[/custom_headline]\r\n\r\n[line style=\"border-top: solid #999999;\"]ArrayFire has worked with hundreds of companies and entrepreneurs to develop custom, high performance software solutions for their unique problems. We use the latest software development methods, profiling tools, and deployment methods to deliver scalable solutions for your present and future business goals.\r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"http://www.sandbox.arrayfire.com/consulting#software-design\" padding_top=\"40px\" padding_bottom=\"40px\"]Read more...[/button]\r\n[/column]\r\n\r\n[column type=\"one-third\" ][custom_headline type=\"left\" level=\"h3\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/09/mini-motorcycle-01-e1412969290876.png\" class=\"mbn\"] System Assessment[/custom_headline][line style=\"border-top: solid #999999;\"]ArrayFire performs holistic application audits that establish the current and theoretical maximum performance your application can achieve. Our methods evaluate everything from the hardware up so you can determine bottlenecks and get the maximum return on investment for future development work.\r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"http://www.sandbox.arrayfire.com/consulting#system-evaluation\" padding_top=\"40px\" padding_bottom=\"40px\"]Read More...[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-third\" last=\"true\" ][custom_headline type=\"left\" level=\"h3\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/09/mini-plane-01-e1412969527633.png\" class=\"mbn\"] Training [/custom_headline][line style=\"border-top: solid #999999;\"]ArrayFire trains your engineers on the latest techniques in parallel computing including CUDA or OpenCL for CPUs, GPUs, FPGAs, and other accelerators. We offer two- and four-day training sessions that are fully customizable so your team learns skills that they need to accelerate your software.\r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"http://www.sandbox.arrayfire.com/training\" padding_top=\"40px\" padding_bottom=\"40px\"]Read More...[/button]\r\n\r\n[/column]\r\n\r\n[/content_band]\r\n\r\n[content_band bg_color=\"#f2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\" class=\"center-text\"]ArrayFire Library[/custom_headline]\r\n\r\nThe ArrayFire accelerated computing library is a free, general-purpose, open-source library that simplifies the process of developing software that targets parallel and massively-parallel architectures including CPUs, GPUs, and other hardware acceleration devices. ArrayFire is used on devices from low-powered mobile phones to high-powered GPU-enabled supercomputers including CPUs from all major vendors (Intel, AMD, Arm), GPUs from the dominant manufacturers (NVIDIA, AMD, and Qualcomm), as well as a variety of other accelerator devices on Windows, Mac, and Linux. \r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"https://www.sandbox.arrayfire.com/download\" padding_top=\"40px\" padding_bottom=\"40px\"]Download ArrayFire[/button]\r\n\r\n[/content_band]\r\n\r\n[content_band bg_color=\"#ffffff\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\" class=\"center-text\"]Domain Specialization[/custom_headline]\r\n\r\nOur engineers are experienced in a wide variety of technical areas of scientific computing including HPC, distributed computing, hardware accelerators (multi-core CPUs, GPUs, FPGAs), and visualization. Our wide skill set enables us to solve your problem in unique ways. Most of our clients hire us because of our experience in one of the following key areas:\r\n\r\n[column type=\"one-fourth\"]\r\n[custom_headline type=\"left\" level=\"h5\" class=\"center-text\"]Computer Vision[/custom_headline]\r\n<a href=\"http://sandbox.arrayfire.com/case-studies/#computer-vision\">\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/photo-computer-vision.jpg\" alt=\"photo-computer-vision\" width=\"341\" height=\"256\" class=\"aligncenter size-full wp-image-9139\" /></a>\r\n[/column]\r\n\r\n[column type=\"one-fourth\"]\r\n[custom_headline type=\"left\" level=\"h5\" class=\"center-text\"]Defense[/custom_headline]\r\n<a href=\"http://sandbox.arrayfire.com/case-studies/#defense\">\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/shadow-of-the-war-1536222.jpg\" alt=\"ship-at-sea\" width=\"384\" height=\"256\" class=\"aligncenter size-full wp-image-9138\" /></a>\r\n[/column]\r\n\r\n[column type=\"one-fourth\"]\r\n[custom_headline type=\"left\" level=\"h5\" class=\"center-text\"]Finance[/custom_headline]\r\n\r\n<a href=\"http://sandbox.arrayfire.com/case-studies/#finance\">\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/photo-computer-finance.jpg\" alt=\"photo-computer-finance\" width=\"384\" height=\"256\" class=\"aligncenter size-full wp-image-9137\" /></a>\r\n\r\n[/column]\r\n\r\n[column type=\"one-fourth\"]\r\n[custom_headline type=\"left\" level=\"h5\" class=\"center-text\"]Machine Learning[/custom_headline]\r\n<a href=\"http://sandbox.arrayfire.com/case-studies/#machine-learning\">\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/photo-ai.jpg\" alt=\"photo-ai\" width=\"334\" height=\"256\" class=\"aligncenter size-full wp-image-9140\" /></a>\r\n<!-- Image credit: https://commons.wikimedia.org/wiki/File:Artificial-intelligence-elon-musk-hawking.jpg -->\r\n[/column]\r\n\r\n[/content_band]','Home','','inherit','closed','closed','','245-revision-v1','','','2017-01-02 15:05:36','2017-01-02 20:05:36','',245,'https://sandbox.arrayfire.com/245-revision-v1/',0,'revision','',0),(9434,17728,'2017-01-02 15:21:19','2017-01-02 20:21:19','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"10px\"][column type=\"two-fifths\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\"]If you want faster code, you\'ve come to the right place.[/custom_headline][gap size=\"3%\"][button  type=\"flat\" shape=\"rounded\" href=\"https://sandbox.arrayfire.com/download\" size=\"x-large\" block=\"true\"]Download ArrayFire[/button]\r\n\r\n[gap size=\"5%\"]\r\n\r\n[button  type=\"flat\" block=\"true\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/consulting/\" size=\"x-large\" ]Schedule a consultation[/button][gap size=\"2%\"]\r\n\r\n[/column][column type=\"three-fifths\" last=\"true\"][gap size=\"7%\"]\r\n<div id=\"wistia_rj2bar3xxp\" class=\"wistia_embed\" style=\"width: 640px; height: 388px;\"></div>\r\n<script src=\"//fast.wistia.com/assets/external/E-v1.js\" charset=\"ISO-8859-1\"></script><script>// <![CDATA[\r\nwistiaEmbed = Wistia.embed(\"rj2bar3xxp\");\r\n// ]]></script>\r\n[/column]\r\n<div id=\"arrayfire\"></div>\r\n[/content_band]\r\n\r\n\r\n[content_band bg_color=\"#f2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\" class=\"center-text\"]Services[/custom_headline]\r\n\r\nArrayFire specializes in developing accelerated, scalable computing solutions on modern computational platforms for our clients. As an industry leader in high performance computing for nearly 10 years, ArrayFire continues to drive innovation in all areas of accelerated computing, ranging from apps deployed on low-powered and mobile platforms to scientific simulations on high-end supercomputers.\r\n\r\n[/content_band]\r\n\r\n[content_band bg_color=\"#ffffff\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"10px\"]\r\n\r\n[column type=\"one-third\" ][custom_headline type=\"left\" level=\"h3\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/car-e1412967813807.png\" class=\"mbn\"] Software Design[/custom_headline]\r\n\r\n[line style=\"border-top: solid #999999;\"]ArrayFire has worked with hundreds of companies and entrepreneurs to develop custom, high performance software solutions for their unique problems. We use the latest software development methods, profiling tools, and deployment methods to deliver scalable solutions for your present and future business goals.\r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"http://www.sandbox.arrayfire.com/consulting#software-design\" padding_top=\"40px\" padding_bottom=\"40px\"]Read more...[/button]\r\n[/column]\r\n\r\n[column type=\"one-third\" ][custom_headline type=\"left\" level=\"h3\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/09/mini-motorcycle-01-e1412969290876.png\" class=\"mbn\"] System Assessment[/custom_headline][line style=\"border-top: solid #999999;\"]ArrayFire performs holistic application audits that establish the current and theoretical maximum performance your application can achieve. Our methods evaluate everything from the hardware up so you can determine bottlenecks and get the maximum return on investment for future development work.\r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"http://www.sandbox.arrayfire.com/consulting#system-evaluation\" padding_top=\"40px\" padding_bottom=\"40px\"]Read More...[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-third\" last=\"true\" ][custom_headline type=\"left\" level=\"h3\" class=\"center-text\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/09/mini-plane-01-e1412969527633.png\" class=\"mbn\"] Training [/custom_headline][line style=\"border-top: solid #999999;\"]ArrayFire trains your engineers on the latest techniques in parallel computing including CUDA or OpenCL for CPUs, GPUs, FPGAs, and other accelerators. We offer two- and four-day training sessions that are fully customizable so your team learns skills that they need to accelerate your software.\r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"http://www.sandbox.arrayfire.com/training\" padding_top=\"40px\" padding_bottom=\"40px\"]Read More...[/button]\r\n\r\n[/column]\r\n\r\n[/content_band]\r\n\r\n[content_band bg_color=\"#f2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\" class=\"center-text\"]ArrayFire Library[/custom_headline]\r\n\r\nThe ArrayFire accelerated computing library is a free, general-purpose, open-source library that simplifies the process of developing software that targets parallel and massively-parallel architectures including CPUs, GPUs, and other hardware acceleration devices. ArrayFire is used on devices from low-powered mobile phones to high-powered GPU-enabled supercomputers including CPUs from all major vendors (Intel, AMD, Arm), GPUs from the dominant manufacturers (NVIDIA, AMD, and Qualcomm), as well as a variety of other accelerator devices on Windows, Mac, and Linux. \r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"https://sandbox.arrayfire.com/download\" padding_top=\"40px\" padding_bottom=\"40px\"]Download ArrayFire[/button]\r\n\r\n[/content_band]\r\n\r\n[content_band bg_color=\"#ffffff\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n\r\n[custom_headline type=\"left\" level=\"h3\" class=\"center-text\"]Domain Specialization[/custom_headline]\r\n\r\nOur engineers are experienced in a wide variety of technical areas of scientific computing including HPC, distributed computing, hardware accelerators (multi-core CPUs, GPUs, FPGAs), and visualization. Our wide skill set enables us to solve your problem in unique ways. Most of our clients hire us because of our experience in one of the following key areas:\r\n\r\n[column type=\"one-fourth\"]\r\n[custom_headline type=\"left\" level=\"h5\" class=\"center-text\"]Computer Vision[/custom_headline]\r\n<a href=\"http://sandbox.arrayfire.com/case-studies/#computer-vision\">\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/photo-computer-vision.jpg\" alt=\"photo-computer-vision\" width=\"341\" height=\"256\" class=\"aligncenter size-full wp-image-9139\" /></a>\r\n[/column]\r\n\r\n[column type=\"one-fourth\"]\r\n[custom_headline type=\"left\" level=\"h5\" class=\"center-text\"]Defense[/custom_headline]\r\n<a href=\"http://sandbox.arrayfire.com/case-studies/#defense\">\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/shadow-of-the-war-1536222.jpg\" alt=\"ship-at-sea\" width=\"384\" height=\"256\" class=\"aligncenter size-full wp-image-9138\" /></a>\r\n[/column]\r\n\r\n[column type=\"one-fourth\"]\r\n[custom_headline type=\"left\" level=\"h5\" class=\"center-text\"]Finance[/custom_headline]\r\n\r\n<a href=\"http://sandbox.arrayfire.com/case-studies/#finance\">\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/photo-computer-finance.jpg\" alt=\"photo-computer-finance\" width=\"384\" height=\"256\" class=\"aligncenter size-full wp-image-9137\" /></a>\r\n\r\n[/column]\r\n\r\n[column type=\"one-fourth\"]\r\n[custom_headline type=\"left\" level=\"h5\" class=\"center-text\"]Machine Learning[/custom_headline]\r\n<a href=\"http://sandbox.arrayfire.com/case-studies/#machine-learning\">\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/photo-ai.jpg\" alt=\"photo-ai\" width=\"334\" height=\"256\" class=\"aligncenter size-full wp-image-9140\" /></a>\r\n<!-- Image credit: https://commons.wikimedia.org/wiki/File:Artificial-intelligence-elon-musk-hawking.jpg -->\r\n[/column]\r\n\r\n[/content_band]','Home','','inherit','closed','closed','','245-revision-v1','','','2017-01-02 15:21:19','2017-01-02 20:21:19','',245,'https://sandbox.arrayfire.com/245-revision-v1/',0,'revision','',0),(9436,18672,'2017-01-02 23:17:04','2017-01-03 04:17:04','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"][column type=\"one-half\" ][custom_headline type=\"left\" level=\"h2\" ]Faster code[/custom_headline]\n\nArrayFire allows your code to run its fastest. It beats efforts to manually write CUDA or OpenCL kernels. It beats compiler optimizations. It beats other libraries. ArrayFire is the simply best way to accelerate your code.\n\nWant proof? Check out our benchmarks. All benchmarks were performed on a NVIDIA Tesla C2050 with an Intel i7-950 processor (updates coming soon). The benchmarks compare ArrayFire with several popular CPU-based acceleration libraries, including <a href=\"http://software.intel.com/en-us/articles/intel-mkl/\" target=\"_new\">Intel Math Kernel Library</a>, <a href=\"http://software.intel.com/en-us/articles/intel-ipp/\" target=\"_new\">Intel Integrated Performance Primitives</a>, <a href=\"http://eigen.tuxfamily.org/index.php?title=Main_Page\" target=\"_new\">Eigen</a>, and <a href=\"http://arma.sourceforge.net/\" target=\"_new\">Armadillo</a>.\n\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"https://sandbox.arrayfire.com/download\" title=\"Download now!\"]Download ArrayFire[/button]\n\n&nbsp;\n\n[/column]\n\n[column type=\"one-half\"  last=\"true\" fade=\"true\" fade_animation=\"in-from-left\" ][gap size=\"10%\"][tab_nav type=\"four-up\"][tab_nav_item title=\"Base\" active=\"true\"][tab_nav_item title=\"Linear Algebra\" active=\"\"][tab_nav_item title=\"Convolution\" active=\"\"][tab_nav_item title=\"Utility\" active=\"\"][/tab_nav][tabs][tab active=\"true\"][accordion id=\"my-accordion\"] [accordion_item title=\"Matrix Multiply\" parent_id=\"my-accordion\"]<img class=\"aligncenter wp-image-351 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/matrix_multiply-e1409845945961.png\" alt=\"Matrix Multiply\" width=\"482\" height=\"344\" />[/accordion_item] [accordion_item title=\"Matrix Transpose\" parent_id=\"my-accordion\"]<img class=\"aligncenter wp-image-352 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/matrix_transpose-e1409846117548.png\" alt=\"Matrix Transpose\" width=\"482\" height=\"344\" />[/accordion_item] [accordion_item title=\"FFT\" parent_id=\"my-accordion\"]<img class=\"aligncenter wp-image-349 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/fft-e1409846374468.png\" alt=\"FFT\" width=\"491\" height=\"350\" />[/accordion_item][/accordion][/tab][tab][accordion id=\"my-accordion\"] [accordion_item title=\"LU\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-350\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/lu-e1409846254351.png\" alt=\"LU\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"SVD\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-357\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/svd-e1409846164788.png\" alt=\"SVD\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"Solve: Ax=b\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-354\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/solve-e1409846072990.png\" alt=\"Solve\" width=\"491\" height=\"350\" />[/accordion_item][/accordion][/tab][tab][accordion id=\"my-accordion\"] [accordion_item title=\"Separable Convolution\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-348\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/convs-e1409846211948.png\" alt=\"Separable Convolution\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"CONV\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-347\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/conv-e1409846333930.png\" alt=\"Conv\" width=\"491\" height=\"350\" />[/accordion_item][/accordion][/tab][tab][accordion id=\"my-accordion\"] [accordion_item title=\"Sum\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-356\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/sum-e1409846033653.png\" alt=\"sum\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"Sort\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-355\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/sort-e1409845987155.png\" alt=\"sort\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"Cumulative Sum\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-353\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/scan-e1409845901355.png\" alt=\"scan\" width=\"491\" height=\"350\" />[/accordion_item][/accordion][/tab][/tabs][/column][/content_band]\n\n[content_band bg_color=\"#f2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\n\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4801 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/comingatyou-e1409844224608.png\" alt=\"comingatyou\" width=\"433\" height=\"302\" />\n\n[gap size=\"13%\"][/column][column type=\"one-half\" last=\"true\"][custom_headline type=\"left\" level=\"h2\"]Hardware neutral[/custom_headline]\n\nArrayFire supports CUDA-capable NVIDIA GPUs, OpenCL devices, and a C-programming backend. The OpenCL devices include AMD GPUs/APUs and Intel Xeon Phi co-processors. It also supports mobile OpenCL devices from ARM, Qualcomm, and others. With ArrayFire, you can easily switch between CUDA or OpenCL without changing your code.\n\nArrayFire is a high-performance software library designed for maximum productivity and speed without the hassle of writing difficult low-level device code. Each of <a href=\"http://www.sandbox.arrayfire.com/docs/modules.htm\">ArrayFire\'s functions</a> has been hand-tuned by our CUDA and OpenCL experts. [gap size=\"5%\"]\n\n[/column]\n\n[/content_band]\n\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\n\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\"]Open Source[/custom_headline]\n\nArrayFire is open source—it’s all there and it’s all free. We\'re big fans of freedom, collaboration, and perpetual motion. Adapt ArrayFire to meet your needs, watch it blaze, and tell us all about it!\n\nBe sure to check out all of the ArrayFire functions (and a lot more!) in our <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">documentation</a>. And don’t forget to visit our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">forums</a> to connect with the ArrayFire community and pick up acceleration tips and best practices. [gap size=\"11%\"]\n\n[/column]\n\n[column type=\"one-fourth\"][gap size=\"40%\"][counter num_start=\"0\" num_end=\"1538\" num_speed=\"5000\"  num_color=\"#f08027\" text_below=\"stars\" text_color=\"#212c43\"]\n\n[counter num_start=\"0\" num_end=\"238\" num_speed=\"5000\"  num_color=\"#f08027\"  text_below=\"forks\" text_color=\"#212c43\"][/column][column type=\"one-fourth\" last=\"true\"][gap size=\"40%\"]\n\n[counter num_start=\"0\" num_end=\"240\" num_speed=\"5000\"  num_color=\"#f08027\"  text_below=\"functions\" text_color=\"#212c43\"]\n\n[counter num_start=\"0\" num_end=\"2438\" num_speed=\"5000\"  num_color=\"#f08027\"  text_below=\"commits\" text_color=\"#212c43\"]\n\n[/column][/content_band]','Why ArrayFire?','','inherit','closed','closed','','7054-autosave-v1','','','2017-01-02 23:17:04','2017-01-03 04:17:04','',7054,'https://sandbox.arrayfire.com/7054-autosave-v1/',0,'revision','',0),(9437,18672,'2017-01-02 23:17:54','2017-01-03 04:17:54','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"][column type=\"one-half\" ][custom_headline type=\"left\" level=\"h2\" ]Faster code[/custom_headline]\r\n\r\nArrayFire allows your code to run its fastest. It beats efforts to manually write CUDA or OpenCL kernels. It beats compiler optimizations. It beats other libraries. ArrayFire is the simply best way to accelerate your code.\r\n\r\nWant proof? Check out our benchmarks. All benchmarks were performed on a NVIDIA Tesla C2050 with an Intel i7-950 processor (updates coming soon). The benchmarks compare ArrayFire with several popular CPU-based acceleration libraries, including <a href=\"http://software.intel.com/en-us/articles/intel-mkl/\" target=\"_new\">Intel Math Kernel Library</a>, <a href=\"http://software.intel.com/en-us/articles/intel-ipp/\" target=\"_new\">Intel Integrated Performance Primitives</a>, <a href=\"http://eigen.tuxfamily.org/index.php?title=Main_Page\" target=\"_new\">Eigen</a>, and <a href=\"http://arma.sourceforge.net/\" target=\"_new\">Armadillo</a>.\r\n\r\n[button type=\"flat\" shape=\"rounded\" size=\"regular\" href=\"https://sandbox.arrayfire.com/download\" title=\"Download now!\"]Download ArrayFire[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\"  last=\"true\" fade=\"true\" fade_animation=\"in-from-left\" ][gap size=\"10%\"][tab_nav type=\"four-up\"][tab_nav_item title=\"Base\" active=\"true\"][tab_nav_item title=\"Linear Algebra\" active=\"\"][tab_nav_item title=\"Convolution\" active=\"\"][tab_nav_item title=\"Utility\" active=\"\"][/tab_nav][tabs][tab active=\"true\"][accordion id=\"my-accordion\"] [accordion_item title=\"Matrix Multiply\" parent_id=\"my-accordion\"]<img class=\"aligncenter wp-image-351 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/matrix_multiply-e1409845945961.png\" alt=\"Matrix Multiply\" width=\"482\" height=\"344\" />[/accordion_item] [accordion_item title=\"Matrix Transpose\" parent_id=\"my-accordion\"]<img class=\"aligncenter wp-image-352 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/matrix_transpose-e1409846117548.png\" alt=\"Matrix Transpose\" width=\"482\" height=\"344\" />[/accordion_item] [accordion_item title=\"FFT\" parent_id=\"my-accordion\"]<img class=\"aligncenter wp-image-349 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/fft-e1409846374468.png\" alt=\"FFT\" width=\"491\" height=\"350\" />[/accordion_item][/accordion][/tab][tab][accordion id=\"my-accordion\"] [accordion_item title=\"LU\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-350\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/lu-e1409846254351.png\" alt=\"LU\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"SVD\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-357\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/svd-e1409846164788.png\" alt=\"SVD\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"Solve: Ax=b\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-354\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/solve-e1409846072990.png\" alt=\"Solve\" width=\"491\" height=\"350\" />[/accordion_item][/accordion][/tab][tab][accordion id=\"my-accordion\"] [accordion_item title=\"Separable Convolution\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-348\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/convs-e1409846211948.png\" alt=\"Separable Convolution\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"CONV\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-347\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/conv-e1409846333930.png\" alt=\"Conv\" width=\"491\" height=\"350\" />[/accordion_item][/accordion][/tab][tab][accordion id=\"my-accordion\"] [accordion_item title=\"Sum\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-356\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/sum-e1409846033653.png\" alt=\"sum\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"Sort\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-355\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/sort-e1409845987155.png\" alt=\"sort\" width=\"491\" height=\"350\" />[/accordion_item] [accordion_item title=\"Cumulative Sum\" parent_id=\"my-accordion\"]<img class=\"aligncenter size-full wp-image-353\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/scan-e1409845901355.png\" alt=\"scan\" width=\"491\" height=\"350\" />[/accordion_item][/accordion][/tab][/tabs][/column][/content_band]\r\n\r\n[content_band bg_color=\"#f2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4801 size-full\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/comingatyou-e1409844224608.png\" alt=\"comingatyou\" width=\"433\" height=\"302\" />\r\n\r\n[gap size=\"13%\"][/column][column type=\"one-half\" last=\"true\"][custom_headline type=\"left\" level=\"h2\"]Hardware neutral[/custom_headline]\r\n\r\nArrayFire supports CUDA-capable NVIDIA GPUs, OpenCL devices, and a C-programming backend. The OpenCL devices include AMD GPUs/APUs and Intel Xeon Phi co-processors. It also supports mobile OpenCL devices from ARM, Qualcomm, and others. With ArrayFire, you can easily switch between CUDA or OpenCL without changing your code.\r\n\r\nArrayFire is a high-performance software library designed for maximum productivity and speed without the hassle of writing difficult low-level device code. Each of <a href=\"http://www.sandbox.arrayfire.com/docs/modules.htm\">ArrayFire\'s functions</a> has been hand-tuned by our CUDA and OpenCL experts. [gap size=\"5%\"]\r\n\r\n[/column]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"40px\" padding_bottom=\"40px\"]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\"]Open Source[/custom_headline]\r\n\r\nArrayFire is open source—it’s all there and it’s all free. We\'re big fans of freedom, collaboration, and perpetual motion. Adapt ArrayFire to meet your needs, watch it blaze, and tell us all about it!\r\n\r\nBe sure to check out all of the ArrayFire functions (and a lot more!) in our <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">documentation</a>. And don’t forget to visit our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">forums</a> to connect with the ArrayFire community and pick up acceleration tips and best practices. [gap size=\"11%\"]\r\n\r\n[/column]\r\n\r\n[column type=\"one-fourth\"][gap size=\"40%\"][counter num_start=\"0\" num_end=\"1538\" num_speed=\"5000\"  num_color=\"#f08027\" text_below=\"stars\" text_color=\"#212c43\"]\r\n\r\n[counter num_start=\"0\" num_end=\"238\" num_speed=\"5000\"  num_color=\"#f08027\"  text_below=\"forks\" text_color=\"#212c43\"][/column][column type=\"one-fourth\" last=\"true\"][gap size=\"40%\"]\r\n\r\n[counter num_start=\"0\" num_end=\"240\" num_speed=\"5000\"  num_color=\"#f08027\"  text_below=\"functions\" text_color=\"#212c43\"]\r\n\r\n[counter num_start=\"0\" num_end=\"4591\" num_speed=\"5000\"  num_color=\"#f08027\"  text_below=\"commits\" text_color=\"#212c43\"]\r\n\r\n[/column][/content_band]','Why ArrayFire?','','inherit','closed','closed','','7054-revision-v1','','','2017-01-02 23:17:54','2017-01-03 04:17:54','',7054,'https://sandbox.arrayfire.com/7054-revision-v1/',0,'revision','',0),(9443,18672,'2017-01-24 14:40:49','2017-01-24 19:40:49','The <a href=\"https://www.catalysts.cc/en/projects/thrombotherm/\">Thrombotherm project</a> by Catalysts is developing a method to analyze blood platelets by means of cell microscopy in real time and to classify them according to their activation state. ArrayFire enabled faster overall research project times and real-time analysis on video data.\r\n\r\nThis project represents an enormous extension of thrombocyte diagnotics, especially through significantly accelerated analysis times. Faster analyses enabled university research collaborators from the University of Applied Sciences OÖ and the Ludwig Boltzmann Institute to shorten research project times.\r\n\r\nThe project has three main parts:\r\n<ol>\r\n 	<li><strong>Detect cell morphology in real-time</strong></li>\r\n</ol>\r\nThombotherm makes it possible to mathematically determine and categorize the cell boundaries by means of transmitted light microscopy. The software distinguishes between \"fried-egg”-shaped cells and \"spider”-shaped cells. This is used to assess the quality of blood platelets in the blink of an eye.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1.png\"><img class=\"alignnone wp-image-9404 size-large\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1-1024x869.png\" alt=\"Fig1\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"2\">\r\n 	<li><strong>Real-time cluster analysis</strong></li>\r\n</ol>\r\nBy means of a fluorescence micrograph, Thrombotherm identifies cell clusters taking into account the diffraction phenomena that occur. This allows a quantitative real-time representation of the platelets in the present sample.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2.png\"><img class=\"alignnone size-large wp-image-9407\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2-1024x869.png\" alt=\"Fig2\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"3\">\r\n 	<li><strong>Real-time analysis of the mobility of receptors</strong></li>\r\n</ol>\r\nThrombotherm also analyzes real-time image sequences. This allows following single molecules and their motion traces. Pixel resolution is not sufficiently accurate, so exact values are calculated with a point spread model. Complex modeling on real-time image sequences is computationally intensive, and ArrayFire enabled realtime computational performance results.\r\n\r\n[video width=\"2000\" height=\"700\" mp4=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Thrombos_epoxy_blog_vid.mp4\" autoplay=\"true\" preload=\"auto\"][/video]\r\n<p style=\"text-align: center;\"><em>Complex calculation of moving images in real time enabled with ArrayFire</em></p>\r\nWith the help of ArrayFire, engineers were able to attain dramatic performance improvements on two of the core algorithmic steps for analyzing real-time image sequences.\r\n\r\nEngineers achieved a <strong>2451X</strong> and a <strong>529X</strong> speedup on both algorithms, respectively, when using ArrayFire over their standard CPU implementation. Significant performance improvements were also observed on both algorithms when using ArrayFire over their standard CUDA implementation using custom kernels - <strong>368X</strong> and <strong>95X</strong> speedups, respectively.\r\n\r\nThrough this completely new method of analyzing thrombocytes, laboratories can identify the mobility of cells, the compression of surface area markers, the morphology of cells, and their activation condition in real-time.','Thrombotherm:  Analyzing Blood Platelets with ArrayFire','','inherit','closed','closed','','9403-autosave-v1','','','2017-01-24 14:40:49','2017-01-24 19:40:49','',9403,'https://sandbox.arrayfire.com/9403-autosave-v1/',0,'revision','',0),(9444,18672,'2017-01-24 14:16:52','2017-01-24 19:16:52','The <a href=\"https://www.catalysts.cc/en/projects/thrombotherm/\">Thrombotherm project</a> by Catalysts is developing a method to analyze blood platelets by means of cell microscopy in real time and to classify them according to their activation state. ArrayFire enabled faster overall research project times and real-time analysis on video data.\r\n\r\nThis project represents an enormous extension of thrombocyte diagnotics, especially through significantly accelerated analysis times. Faster analyses enabled university research collaborators from the University of Applied Sciences OÖ and the Ludwig Boltzmann Institute to shorten research project times.\r\n\r\nThe project has three main parts:\r\n<ol>\r\n 	<li><strong>Detect cell morphology in real-time</strong></li>\r\n</ol>\r\nThombotherm makes it possible to mathematically determine and categorize the cell boundaries by means of transmitted light microscopy. The software distinguishes between \"fried-egg”-shaped cells and \"spider”-shaped cells. This is used to assess the quality of blood platelets in the blink of an eye.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1.png\"><img class=\"alignnone wp-image-9404 size-large\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1-1024x869.png\" alt=\"Fig1\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"2\">\r\n 	<li><strong>Real-time cluster analysis</strong></li>\r\n</ol>\r\nBy means of a fluorescence micrograph, Thrombotherm identifies cell clusters taking into account the diffraction phenomena that occur. This allows a quantitative real-time representation of the platelets in the present sample.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2.png\"><img class=\"alignnone size-large wp-image-9407\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2-1024x869.png\" alt=\"Fig2\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"3\">\r\n 	<li><strong>Real-time analysis of the mobility of receptors</strong></li>\r\n</ol>\r\nThrombotherm also analyzes real-time image sequences. This allows following single molecules and their motion traces. Pixel resolution is not sufficiently accurate, so exact values are calculated with a point spread model. Complex modeling on real-time image sequences is computationally intensive, and ArrayFire enabled realtime computational performance results.\r\n\r\n[video width=\"2000\" height=\"700\" mp4=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Thrombos_epoxy_blog_vid.mp4\" autoplay=\"true\" preload=\"auto\"][/video]\r\n<p style=\"text-align: center;\"><em>Complex calculation of moving images in real time enabled with ArrayFire</em></p>\r\nWith the help of ArrayFire, engineers were able to achieve dramatic performance improvements on two of the core algorithmic steps for analyzing real-time image sequences. For the first algorithm, engineers observed a <strong>2451X</strong> speedup and a <strong>529X</strong> speedup with ArrayFire over a CPU implementation and a CUDA implementation using custom kernels, respectively. For the second algorithm, engineers observed a <strong>368X</strong> speedup and a <strong>95X</strong> speedup with ArrayFire over a CPU implementation and a CUDA implementation using custom kernels, respectively.\r\n\r\nThrough this completely new method of analyzing thrombocytes, laboratories can identify the mobility of cells, the compression of surface area markers, the morphology of cells, and their activation condition in real-time.','Thrombotherm:  Analyzing Blood Platelets with ArrayFire','','inherit','closed','closed','','9403-revision-v1','','','2017-01-24 14:16:52','2017-01-24 19:16:52','',9403,'https://sandbox.arrayfire.com/9403-revision-v1/',0,'revision','',0),(9445,18672,'2017-01-24 14:39:44','2017-01-24 19:39:44','The <a href=\"https://www.catalysts.cc/en/projects/thrombotherm/\">Thrombotherm project</a> by Catalysts is developing a method to analyze blood platelets by means of cell microscopy in real time and to classify them according to their activation state. ArrayFire enabled faster overall research project times and real-time analysis on video data.\r\n\r\nThis project represents an enormous extension of thrombocyte diagnotics, especially through significantly accelerated analysis times. Faster analyses enabled university research collaborators from the University of Applied Sciences OÖ and the Ludwig Boltzmann Institute to shorten research project times.\r\n\r\nThe project has three main parts:\r\n<ol>\r\n 	<li><strong>Detect cell morphology in real-time</strong></li>\r\n</ol>\r\nThombotherm makes it possible to mathematically determine and categorize the cell boundaries by means of transmitted light microscopy. The software distinguishes between \"fried-egg”-shaped cells and \"spider”-shaped cells. This is used to assess the quality of blood platelets in the blink of an eye.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1.png\"><img class=\"alignnone wp-image-9404 size-large\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1-1024x869.png\" alt=\"Fig1\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"2\">\r\n 	<li><strong>Real-time cluster analysis</strong></li>\r\n</ol>\r\nBy means of a fluorescence micrograph, Thrombotherm identifies cell clusters taking into account the diffraction phenomena that occur. This allows a quantitative real-time representation of the platelets in the present sample.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2.png\"><img class=\"alignnone size-large wp-image-9407\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2-1024x869.png\" alt=\"Fig2\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"3\">\r\n 	<li><strong>Real-time analysis of the mobility of receptors</strong></li>\r\n</ol>\r\nThrombotherm also analyzes real-time image sequences. This allows following single molecules and their motion traces. Pixel resolution is not sufficiently accurate, so exact values are calculated with a point spread model. Complex modeling on real-time image sequences is computationally intensive, and ArrayFire enabled realtime computational performance results.\r\n\r\n[video width=\"2000\" height=\"700\" mp4=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Thrombos_epoxy_blog_vid.mp4\" autoplay=\"true\" preload=\"auto\"][/video]\r\n<p style=\"text-align: center;\"><em>Complex calculation of moving images in real time enabled with ArrayFire</em></p>\r\nWith the help of ArrayFire, engineers were able to attain dramatic performance improvements on two of the core algorithmic steps for analyzing real-time image sequences.\r\n\r\nEngineers achieved a *2451X* and a *529X* speedup on both algorithms, respectively, when using ArrayFire over their standard CPU implementation. Significant performance improvements were also observed on\r\nboth algorithms when using ArrayFire over their standard CUDA implementation using custom kernels - *368X* and *95X* speedups, respectively.\r\n\r\nThrough this completely new method of analyzing thrombocytes, laboratories can identify the mobility of cells, the compression of surface area markers, the morphology of cells, and their activation condition in real-time.','Thrombotherm:  Analyzing Blood Platelets with ArrayFire','','inherit','closed','closed','','9403-revision-v1','','','2017-01-24 14:39:44','2017-01-24 19:39:44','',9403,'https://sandbox.arrayfire.com/9403-revision-v1/',0,'revision','',0),(9446,18672,'2017-01-24 14:40:22','2017-01-24 19:40:22','The <a href=\"https://www.catalysts.cc/en/projects/thrombotherm/\">Thrombotherm project</a> by Catalysts is developing a method to analyze blood platelets by means of cell microscopy in real time and to classify them according to their activation state. ArrayFire enabled faster overall research project times and real-time analysis on video data.\r\n\r\nThis project represents an enormous extension of thrombocyte diagnotics, especially through significantly accelerated analysis times. Faster analyses enabled university research collaborators from the University of Applied Sciences OÖ and the Ludwig Boltzmann Institute to shorten research project times.\r\n\r\nThe project has three main parts:\r\n<ol>\r\n 	<li><strong>Detect cell morphology in real-time</strong></li>\r\n</ol>\r\nThombotherm makes it possible to mathematically determine and categorize the cell boundaries by means of transmitted light microscopy. The software distinguishes between \"fried-egg”-shaped cells and \"spider”-shaped cells. This is used to assess the quality of blood platelets in the blink of an eye.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1.png\"><img class=\"alignnone wp-image-9404 size-large\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1-1024x869.png\" alt=\"Fig1\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"2\">\r\n 	<li><strong>Real-time cluster analysis</strong></li>\r\n</ol>\r\nBy means of a fluorescence micrograph, Thrombotherm identifies cell clusters taking into account the diffraction phenomena that occur. This allows a quantitative real-time representation of the platelets in the present sample.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2.png\"><img class=\"alignnone size-large wp-image-9407\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2-1024x869.png\" alt=\"Fig2\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"3\">\r\n 	<li><strong>Real-time analysis of the mobility of receptors</strong></li>\r\n</ol>\r\nThrombotherm also analyzes real-time image sequences. This allows following single molecules and their motion traces. Pixel resolution is not sufficiently accurate, so exact values are calculated with a point spread model. Complex modeling on real-time image sequences is computationally intensive, and ArrayFire enabled realtime computational performance results.\r\n\r\n[video width=\"2000\" height=\"700\" mp4=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Thrombos_epoxy_blog_vid.mp4\" autoplay=\"true\" preload=\"auto\"][/video]\r\n<p style=\"text-align: center;\"><em>Complex calculation of moving images in real time enabled with ArrayFire</em></p>\r\nWith the help of ArrayFire, engineers were able to attain dramatic performance improvements on two of the core algorithmic steps for analyzing real-time image sequences.\r\n\r\nEngineers achieved a <strong>2451X</strong> and a <strong>529X</strong> speedup on both algorithms, respectively, when using ArrayFire over their standard CPU implementation. Significant performance improvements were also observed on\r\nboth algorithms when using ArrayFire over their standard CUDA implementation using custom kernels - <strong>368X</strong> and <strong>95X</strong> speedups, respectively.\r\n\r\nThrough this completely new method of analyzing thrombocytes, laboratories can identify the mobility of cells, the compression of surface area markers, the morphology of cells, and their activation condition in real-time.','Thrombotherm:  Analyzing Blood Platelets with ArrayFire','','inherit','closed','closed','','9403-revision-v1','','','2017-01-24 14:40:22','2017-01-24 19:40:22','',9403,'https://sandbox.arrayfire.com/9403-revision-v1/',0,'revision','',0),(9447,18672,'2017-01-24 14:40:44','2017-01-24 19:40:44','The <a href=\"https://www.catalysts.cc/en/projects/thrombotherm/\">Thrombotherm project</a> by Catalysts is developing a method to analyze blood platelets by means of cell microscopy in real time and to classify them according to their activation state. ArrayFire enabled faster overall research project times and real-time analysis on video data.\r\n\r\nThis project represents an enormous extension of thrombocyte diagnotics, especially through significantly accelerated analysis times. Faster analyses enabled university research collaborators from the University of Applied Sciences OÖ and the Ludwig Boltzmann Institute to shorten research project times.\r\n\r\nThe project has three main parts:\r\n<ol>\r\n 	<li><strong>Detect cell morphology in real-time</strong></li>\r\n</ol>\r\nThombotherm makes it possible to mathematically determine and categorize the cell boundaries by means of transmitted light microscopy. The software distinguishes between \"fried-egg”-shaped cells and \"spider”-shaped cells. This is used to assess the quality of blood platelets in the blink of an eye.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1.png\"><img class=\"alignnone wp-image-9404 size-large\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1-1024x869.png\" alt=\"Fig1\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"2\">\r\n 	<li><strong>Real-time cluster analysis</strong></li>\r\n</ol>\r\nBy means of a fluorescence micrograph, Thrombotherm identifies cell clusters taking into account the diffraction phenomena that occur. This allows a quantitative real-time representation of the platelets in the present sample.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2.png\"><img class=\"alignnone size-large wp-image-9407\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2-1024x869.png\" alt=\"Fig2\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"3\">\r\n 	<li><strong>Real-time analysis of the mobility of receptors</strong></li>\r\n</ol>\r\nThrombotherm also analyzes real-time image sequences. This allows following single molecules and their motion traces. Pixel resolution is not sufficiently accurate, so exact values are calculated with a point spread model. Complex modeling on real-time image sequences is computationally intensive, and ArrayFire enabled realtime computational performance results.\r\n\r\n[video width=\"2000\" height=\"700\" mp4=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Thrombos_epoxy_blog_vid.mp4\" autoplay=\"true\" preload=\"auto\"][/video]\r\n<p style=\"text-align: center;\"><em>Complex calculation of moving images in real time enabled with ArrayFire</em></p>\r\nWith the help of ArrayFire, engineers were able to attain dramatic performance improvements on two of the core algorithmic steps for analyzing real-time image sequences.\r\n\r\nEngineers achieved a <strong>2451X</strong> and a <strong>529X</strong> speedup on both algorithms, respectively, when using ArrayFire over their standard CPU implementation. Significant performance improvements were also observed on both algorithms when using ArrayFire over their standard CUDA implementation using custom kernels - <strong>368X</strong> and <strong>95X</strong> speedups, respectively.\r\n\r\nThrough this completely new method of analyzing thrombocytes, laboratories can identify the mobility of cells, the compression of surface area markers, the morphology of cells, and their activation condition in real-time.','Thrombotherm:  Analyzing Blood Platelets with ArrayFire','','inherit','closed','closed','','9403-revision-v1','','','2017-01-24 14:40:44','2017-01-24 19:40:44','',9403,'https://sandbox.arrayfire.com/9403-revision-v1/',0,'revision','',0),(9450,4,'2017-01-26 20:10:34','0000-00-00 00:00:00','The popular benchmarking website <a href=\"http://www.phoronix.com\">Phoronix</a> recently released an <a href=\"http://www.phoronix.com/scan.php?page=news_item&amp;px=ArrayFire-PTS-Testing\">ArrayFire benchmarking suite</a>. We are excited to have convenient benchmarks publicly available for our community.\r\n\r\nWe are very pleased for the release of this suite and look forward to working with Michael and his team to refine and enhance the ability of this tool to relay accurate performance benchmarks to the computing community.\r\n\r\nPhoronix followed up posting two different articles relaying benchmarks from this initial suite:\r\n<ul>\r\n 	<li><a href=\"http://www.phoronix.com/scan.php?page=news_item&amp;px=ArrayFire-NVIDIA-Pascal-Linux\">Benchmarks of NVIDIA GPUs</a></li>\r\n 	<li><a href=\"http://www.phoronix.com/scan.php?page=article&amp;item=arrayfire-amd-nvidia&amp;num=1\">Benchmarks of NVIDIA vs AMD GPUs using OpenCL</a></li>\r\n</ul>\r\nOur comment on these first benchmarks from this initial benchmarking suite is that they could be tweaked to give a more clear picture of the actual compute capacity of a particular hardware device. There are many things we envision doing in the future with Phoronix to make the suite more useful to the community. Here are ideas we have now:','Phoronix Releases an ArrayFire Benchmarking Suite','','draft','open','closed','','','','','2017-01-26 20:10:34','2017-01-27 01:10:34','',0,'https://sandbox.arrayfire.com/?p=9450',0,'post','',0),(9451,4,'2017-01-26 20:10:29','2017-01-27 01:10:29','The popular benchmarking website <a href=\"http://www.phoronix.com\">Phoronix</a> recently released an <a href=\"http://www.phoronix.com/scan.php?page=news_item&amp;px=ArrayFire-PTS-Testing\">ArrayFire benchmarking suite</a>. We are excited to have convenient benchmarks publicly available for our community.\r\n\r\nWe are very pleased for the release of this suite and look forward to working with Michael and his team to refine and enhance the ability of this tool to relay accurate performance benchmarks to the computing community.\r\n\r\nPhoronix followed up posting two different articles relaying benchmarks from this initial suite:\r\n<ul>\r\n 	<li><a href=\"http://www.phoronix.com/scan.php?page=news_item&amp;px=ArrayFire-NVIDIA-Pascal-Linux\">Benchmarks of NVIDIA GPUs</a></li>\r\n 	<li><a href=\"http://www.phoronix.com/scan.php?page=article&amp;item=arrayfire-amd-nvidia&amp;num=1\">Benchmarks of NVIDIA vs AMD GPUs using OpenCL</a></li>\r\n</ul>\r\nOur comment on these first benchmarks from this initial benchmarking suite is that they could be tweaked to give a more clear picture of the actual compute capacity of a particular hardware device. There are many things we envision doing in the future with Phoronix to make the suite more useful to the community. Here are ideas we have now:','Phoronix Releases an ArrayFire Benchmarking Suite','','inherit','closed','closed','','9450-revision-v1','','','2017-01-26 20:10:29','2017-01-27 01:10:29','',9450,'https://sandbox.arrayfire.com/9450-revision-v1/',0,'revision','',0),(9455,6,'2017-02-08 14:32:15','2017-02-08 19:32:15','The <a href=\"https://www.catalysts.cc/en/projects/thrombotherm/\">Thrombotherm project</a> by Catalysts is developing a method to analyze blood platelets by means of cell microscopy in real time and to classify them according to their activation state. ArrayFire enabled faster overall research project times and real-time analysis on video data.\r\n\r\nThis project represents an enormous extension of thrombocyte diagnotics, especially through significantly accelerated analysis times. Faster analyses enabled university research collaborators from the University of Applied Sciences OÖ and the Ludwig Boltzmann Institute to shorten research project times.\r\n\r\nThe project has three main parts:\r\n<ol>\r\n 	<li><strong>Detect cell morphology in real-time</strong></li>\r\n</ol>\r\nThombotherm makes it possible to mathematically determine and categorize the cell boundaries by means of transmitted light microscopy. The software distinguishes between \"fried-egg”-shaped cells and \"spider”-shaped cells. This is used to assess the quality of blood platelets in the blink of an eye.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1.png\"><img class=\"alignnone wp-image-9404 size-large\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig1-1024x869.png\" alt=\"Fig1\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"2\">\r\n 	<li><strong>Real-time cluster analysis</strong></li>\r\n</ol>\r\nBy means of a fluorescence micrograph, Thrombotherm identifies cell clusters taking into account the diffraction phenomena that occur. This allows a quantitative real-time representation of the platelets in the present sample.\r\n\r\n<a href=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2.png\"><img class=\"alignnone size-large wp-image-9407\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Fig2-1024x869.png\" alt=\"Fig2\" width=\"742\" height=\"630\" /></a>\r\n<ol start=\"3\">\r\n 	<li><strong>Real-time analysis of the mobility of receptors</strong></li>\r\n</ol>\r\nThrombotherm also analyzes real-time image sequences. This allows following single molecules and their motion traces. Pixel resolution is not sufficiently accurate, so exact values are calculated with a point spread model. Complex modeling on real-time image sequences is computationally intensive, and ArrayFire enabled realtime computational performance results.\r\n\r\n[video width=\"2000\" height=\"700\" mp4=\"http://sandbox.arrayfire.com/wp-content/uploads/2016/12/Thrombos_epoxy_blog_vid.mp4\" autoplay=\"true\" preload=\"auto\"][/video]\r\n<p style=\"text-align: center;\"><em>Complex calculation of moving images in real time enabled with ArrayFire</em></p>\r\nWith the help of ArrayFire, engineers were able to attain dramatic performance improvements on two of the core algorithmic steps for analyzing real-time image sequences.\r\n\r\nEngineers achieved a <strong>2451X</strong> and a <strong>529X</strong> speedup on both algorithms, respectively, when using ArrayFire over their standard CPU implementation. Significant performance improvements were also observed on both algorithms when using ArrayFire over their standard CUDA implementation using custom kernels - <strong>368X</strong> and <strong>95X</strong> speedups, respectively.\r\n\r\nThrough this completely new method of analyzing thrombocytes, laboratories can identify the mobility of cells, the compression of surface area markers, the morphology of cells, and their activation condition in real-time.','Thrombotherm:  Analyzing Blood Platelets with ArrayFire','','inherit','closed','closed','','9403-autosave-v1','','','2017-02-08 14:32:15','2017-02-08 19:32:15','',9403,'https://sandbox.arrayfire.com/9403-autosave-v1/',0,'revision','',0),(9456,18672,'2017-02-08 19:37:38','2017-02-09 00:37:38','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n<h3>Improvements to the ArrayFire Library</h3>\r\nArrayFire aims to be a portable, high performance scientific computing library. Key areas in ArrayFire can be improved include:\r\n<ul>\r\n 	<li>Improving the performance of existing functions</li>\r\n 	<li>Adding support for more hardware and backends</li>\r\n 	<li>Adding a new domain of functions</li>\r\n</ul>\r\nWith these in mind, we suggest the follow ideas for prospective GSOC17 students.\r\n<h6>IMPLEMENT PARALLEL VERSION OF ARRAYFIRE\'S CPU BACKEND</h6>\r\nThis project focuses on performance improvements to ArrayFire\'s CPU backend. This is done by adding both vectorization and multi-threading support.\r\n\r\nA successful project will implement the following tasks.\r\n<ul>\r\n 	<li>Use existing libraries (MKL, ACML, IPP etc) to accelerate when possible.</li>\r\n 	<li>Use SSE instructions to vectorize key algorithms</li>\r\n 	<li>Use OpenMP to enable multi-threading support.</li>\r\n</ul>\r\n<h6>MACHINE LEARNING ALGORITHMS FOR ARRAYFIRE</h6>\r\nThese algorithms will be written using existing functionality. While no knowledge of CUDA or OpenCL is necessary, familiarity with vectorization concepts is important. A successful project will implement any three of the following tasks using ArrayFire.\r\n<ul>\r\n 	<li>Logistic and Linear regression</li>\r\n 	<li>Expectation Maximization</li>\r\n 	<li>Principal Component Analysis</li>\r\n 	<li>Support Vector Machines</li>\r\n 	<li>Hidden Markov Models</li>\r\n 	<li>Self Organizing Maps</li>\r\n 	<li>Performance improvements to existing Machine Learning algorithms</li>\r\n</ul>\r\n<h6>COMPUTER VISION ALGORITHMS FOR ARRAYFIRE</h6>\r\nThese algorithms will be written in CUDA or OpenCL, along with a CPU implementation (serial), using ArrayFire existing functionality when available. A successful project will implement any one of the following tasks in CUDA or OpenCL plus a CPU implementation in C++:\r\n<ul>\r\n 	<li>SURF</li>\r\n 	<li><a href=\"http://personal.ee.surrey.ac.uk/Personal/Z.Kalal/tld.html\">Tracking-Learning-Detection</a> (TLD)</li>\r\n 	<li><a href=\"http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html\">Accelerated-KAZE Features</a> (AKAZE)</li>\r\n</ul>\r\n<h3>Language Bindings for ArrayFire</h3>\r\nThere are a lot of Scientists and Engineers using higher level languages for scientific computing. ArrayFire\'s C API allows us to write wrappers for high level languages fairly easily. GSOC students can pick a language of their choice and wrap ArrayFire in that language. Our suggestions include the following.\r\n<h6>JAVA WRAPPER FOR ARRAYFIRE</h6>\r\nA Java wrapper already exists for ArrayFire. However it does not have feature parity with the C/C++ version. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux, Windows and OSX</li>\r\n 	<li>Write two new examples demonstrating the wrapper</li>\r\n</ul>\r\n<h6>R WRAPPER FOR ARRAYFIRE</h6>\r\nAs with the Java wrapper, the R wrapper does not have feature parity. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux and OSX</li>\r\n 	<li>Benchmark ArrayFire\'s algorithms with standard implementations in R</li>\r\n</ul>\r\n<h6>OTHER LANGUAGE WRAPPERS</h6>\r\nSuggested languages include: C#, lua and rust. If you prefer a different language, contact us. A successful project will implement the following.\r\n<ul>\r\n 	<li>implement functions from <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/algorithm.h\">arith.h</a>, <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/arith.h\">algorithm.h</a> and <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/blas.h\">blas.h</a></li>\r\n 	<li>Test the wrapper on Linux</li>\r\n 	<li>Write at least one example demonstrating the wrapper</li>\r\n</ul>','GSoC 17 Ideas Page','','publish','closed','closed','','gsoc-17-ideas-page','','','2017-02-11 00:42:46','2017-02-11 05:42:46','',0,'https://sandbox.arrayfire.com/?page_id=9456',0,'page','',0),(9457,18672,'2017-02-08 19:28:48','2017-02-09 00:28:48','<b>New features</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new feature in ArrayFire for multiple backends. This will require cooperation with different developers to optimize performance over the different architectures ArrayFire targets.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new computer vision function.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement CPU backend parallelization.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Eigensolvers for CPU/CUDA/OpenCL.</span></li>\r\n</ul>\r\n<b>Wrappers</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement .NET wrapper.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Java wrapper (targeting Android platform).</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve R wrapper.</span></li>\r\n</ul>\r\n<b>Architecture and build systems</b>\r\n<ul>\r\n 	<li>AF 4.0 - modularize all computer vision functions.</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Document internal ArrayFire API. </span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve testing.</span></li>\r\n</ul>\r\n<b>Display and user interaction (Forge):</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Helper functions for loading video and processing video frames - `imgload()`, `show()`.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Integrate other plotting library backends - `matplotlib`, `gnuplot`, etc.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Forge Interaction</span></li>\r\n</ul>\r\n<b>Machine Learning</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Provide interface to cuDNN.</span>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Equivalent opencl implementation?</span></li>\r\n</ul>\r\n</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-08 19:28:48','2017-02-09 00:28:48','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9458,18672,'2017-02-08 19:31:39','2017-02-09 00:31:39','<b>New features</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new feature in ArrayFire for multiple backends. This will require cooperation with different developers to optimize performance over the different architectures ArrayFire targets.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new computer vision function.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement CPU backend parallelization.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Eigensolvers for CPU/CUDA/OpenCL.</span></li>\r\n</ul>\r\n<b>Wrappers</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement .NET wrapper.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Java wrapper (targeting Android platform).</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve R wrapper.</span></li>\r\n</ul>\r\n<b>Architecture and build systems</b>\r\n<ul>\r\n 	<li>AF 4.0 - modularize all computer vision functions.</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Document internal ArrayFire API. </span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve testing.</span></li>\r\n</ul>\r\n<b>Display and user interaction (Forge):</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Helper functions for loading video and processing video frames - <code>imgload()</code>, <code>show()</code>.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Integrate other plotting library backends - <code>matplotlib</code>, <code>gnuplot</code>, etc.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Forge Interaction</span></li>\r\n</ul>\r\n<b>Machine Learning</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Provide interface to cuDNN.</span>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Equivalent opencl implementation?</span></li>\r\n</ul>\r\n</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-08 19:31:39','2017-02-09 00:31:39','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9459,18672,'2017-02-08 19:37:27','2017-02-09 00:37:27','<b>New features</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new feature in ArrayFire for multiple backends. This will require cooperation with different developers to optimize performance over the different architectures ArrayFire targets.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new computer vision function.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement CPU backend parallelization.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Eigensolvers for CPU/CUDA/OpenCL.</span></li>\r\n</ul>\r\n<b>Wrappers</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement .NET wrapper.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Java wrapper (targeting Android platform).</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve R wrapper.</span></li>\r\n</ul>\r\n<b>Architecture and build systems</b>\r\n<ul>\r\n 	<li>AF 4.0 - modularize all computer vision functions.</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Document internal ArrayFire API. </span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve testing.</span></li>\r\n</ul>\r\n<b>Display and user interaction:</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Helper functions for loading video and processing video frames - <code>imgload()</code>, <code>show()</code>.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Integrate other plotting library backends - <code>matplotlib</code>, <code>gnuplot</code>, etc.</span></li>\r\n</ul>\r\n<b>Machine Learning</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Provide interface to cuDNN.</span>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Equivalent OpenCL implementation?</span></li>\r\n</ul>\r\n</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-08 19:37:27','2017-02-09 00:37:27','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9461,18672,'2017-02-09 14:28:01','2017-02-09 19:28:01','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the title.\r\n\r\n<b>New features</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new feature in ArrayFire for multiple backends. This will require cooperation with different developers to optimize performance over the different architectures ArrayFire targets.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new computer vision functions/features, such as:</span>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\">SURF</li>\r\n 	<li style=\"font-weight: 400;\">AKAZE</li>\r\n</ul>\r\n</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement CPU backend parallelization using OpenCL or OpenMP</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Eigensolvers for CPU/CUDA/OpenCL</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement linear solvers for CPU/CUDA/OpenCL</span></li>\r\n</ul>\r\n<b>Wrappers</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement .NET wrapper</span></li>\r\n 	<li style=\"font-weight: 400;\">Improve R wrapper</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Java wrapper (targeting Android platform)</span></li>\r\n</ul>\r\n<b>Architecture and build systems</b>\r\n<ul>\r\n 	<li>Modularize ArrayFire</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Document internal ArrayFire API</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve testing</span></li>\r\n</ul>\r\n<b>Display and user interaction:</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Helper functions for loading video and processing video frames - imgload(), show()</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Integrate other plotting library backends - matplotlib, gnuplot, etc</span></li>\r\n</ul>\r\n<b>Machine Learning</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\">Implement machine learning functions such as PCA</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-09 14:28:01','2017-02-09 19:28:01','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9462,18672,'2017-02-09 14:28:24','2017-02-09 19:28:24','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n\r\n<b>New features</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new feature in ArrayFire for multiple backends. This will require cooperation with different developers to optimize performance over the different architectures ArrayFire targets.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new computer vision functions/features, such as:</span>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\">SURF</li>\r\n 	<li style=\"font-weight: 400;\">AKAZE</li>\r\n</ul>\r\n</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement CPU backend parallelization using OpenCL or OpenMP</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Eigensolvers for CPU/CUDA/OpenCL</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement linear solvers for CPU/CUDA/OpenCL</span></li>\r\n</ul>\r\n<b>Wrappers</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement .NET wrapper</span></li>\r\n 	<li style=\"font-weight: 400;\">Improve R wrapper</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Java wrapper (targeting Android platform)</span></li>\r\n</ul>\r\n<b>Architecture and build systems</b>\r\n<ul>\r\n 	<li>Modularize ArrayFire</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Document internal ArrayFire API</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve testing</span></li>\r\n</ul>\r\n<b>Display and user interaction:</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Helper functions for loading video and processing video frames - imgload(), show()</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Integrate other plotting library backends - matplotlib, gnuplot, etc</span></li>\r\n</ul>\r\n<b>Machine Learning</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\">Implement machine learning functions such as PCA</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-09 14:28:24','2017-02-09 19:28:24','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9463,18672,'2017-02-09 14:33:29','2017-02-09 19:33:29','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n\r\n<b>New features</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new feature in ArrayFire for multiple backends. This will require cooperation with different developers to optimize performance over the different architectures ArrayFire targets.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement new computer vision functions/features, such as:</span>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\">SURF</li>\r\n 	<li style=\"font-weight: 400;\">AKAZE</li>\r\n</ul>\r\n</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement CPU backend parallelization using OpenCL or OpenMP</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Eigensolvers</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement linear solvers</span></li>\r\n 	<li style=\"font-weight: 400;\">Implement PDE solvers</li>\r\n 	<li style=\"font-weight: 400;\">Implement non-uniform FFT</li>\r\n 	<li style=\"font-weight: 400;\">Write new examples for ArrayFire</li>\r\n</ul>\r\n<b>Wrappers</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement .NET wrapper</span></li>\r\n 	<li style=\"font-weight: 400;\">Improve R wrapper</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Java wrapper (targeting Android platform)</span></li>\r\n</ul>\r\n<b>Architecture and build systems</b>\r\n<ul>\r\n 	<li>Modularize ArrayFire</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Document internal ArrayFire API</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve testing</span></li>\r\n</ul>\r\n<b>Display and user interaction:</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Helper functions for loading video and processing video frames - imgload(), show()</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Integrate other plotting library backends - matplotlib, gnuplot, etc</span></li>\r\n</ul>\r\n<b>Machine Learning</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\">Implement machine learning functions such as PCA</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-09 14:33:29','2017-02-09 19:33:29','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9464,18672,'2017-02-09 15:53:52','2017-02-09 20:53:52','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n\r\n<b>New features</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement a new feature in ArrayFire for multiple backends. This will require cooperation with different developers to optimize performance over the different architectures ArrayFire targets.</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement new computer vision functions/features, such as:</span>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\">SURF</li>\r\n 	<li style=\"font-weight: 400;\">AKAZE</li>\r\n</ul>\r\n</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement CPU backend parallelization using OpenCL or OpenMP</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Eigensolvers</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement linear solvers</span></li>\r\n 	<li style=\"font-weight: 400;\">Implement PDE solvers</li>\r\n 	<li style=\"font-weight: 400;\">Implement non-uniform FFT</li>\r\n 	<li style=\"font-weight: 400;\">Write new examples for ArrayFire</li>\r\n</ul>\r\n<b>Wrappers</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement .NET wrapper</span></li>\r\n 	<li style=\"font-weight: 400;\">Improve R wrapper</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Implement Java wrapper (targeting Android platform)</span></li>\r\n</ul>\r\n<b>Architecture and build systems</b>\r\n<ul>\r\n 	<li>Modularize ArrayFire</li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Document internal ArrayFire API</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Improve testing</span></li>\r\n</ul>\r\n<b>Display and user interaction</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Helper functions for loading video and processing video frames - imgload(), show()</span></li>\r\n 	<li style=\"font-weight: 400;\"><span style=\"font-weight: 400;\">Integrate other plotting library backends - matplotlib, gnuplot, etc</span></li>\r\n</ul>\r\n<b>Machine Learning</b>\r\n<ul>\r\n 	<li style=\"font-weight: 400;\">Implement machine learning functions such as PCA</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-09 15:53:52','2017-02-09 20:53:52','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9465,18672,'2017-02-10 15:05:44','2017-02-10 20:05:44','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/windows-installer\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-x86_64-installer\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/ltx4p\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-armv7l-installer\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2017-02-10 15:05:44','2017-02-10 20:05:44','',5931,'https://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9466,18672,'2017-02-10 15:12:43','2017-02-10 20:12:43','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/windows-installer\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-x86_64-installer\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/l/37882/2015-03-19/ltx4p\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-armv7l-installer\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2017-02-10 15:12:43','2017-02-10 20:12:43','',5931,'https://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9467,18672,'2017-02-10 15:29:19','2017-02-10 20:29:19','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/windows-installer\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-x86_64-installer\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/osx-installer\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-armv7l-installer\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2017-02-10 15:29:19','2017-02-10 20:29:19','',5931,'https://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9468,18672,'2017-02-10 15:35:59','2017-02-10 20:35:59','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/windows-installer\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-x86_64-installer\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.sandbox.arrayfire.com/l/37882/2015-03-19/ltx4p\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-armv7l-installer\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2017-02-10 15:35:59','2017-02-10 20:35:59','',5931,'https://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9469,18672,'2018-07-26 10:15:21','2018-07-26 14:15:21','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\n[custom_headline type=\"left\" level=\"h2\"]\nArrayFire Installers\n[/custom_headline]\n[custom_headline type=\"left\" level=\"h5\"]\nEach download contains both CUDA and OpenCL files.\n[/custom_headline]\n[gap size=\"4%\"]\n\n[column type=\"one-fourth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\nIn your html page, add the snippet and call\ngoog_report_conversion when someone clicks on the\nchosen link or button. --&gt;\n&lt;script type=\"text/javascript\"&gt;\n/* &lt;!&amp;#91;CDATA&amp;#91; */\ngoog_snippet_vars = function() {\nvar w = window;\nw.google_conversion_id = 1021026651;\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\nw.google_remarketing_only = false;\n}\n// DO NOT CHANGE THE CODE BELOW.\ngoog_report_conversion = function(url) {\ngoog_snippet_vars();\nwindow.google_conversion_format = \"3\";\nwindow.google_is_call = true;\nvar opt = new Object();\nopt.onload_callback = function() {\nif (typeof(url) != \'undefined\') {\nwindow.location = url;\n}\n}\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\nif (typeof(conv_handler) == \'function\') {\nconv_handler(opt);\n}\n}\n/* &amp;#93;&amp;#93;&gt; */\n&lt;/script&gt;\n&lt;script type=\"text/javascript\"\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lvvyk\" size=\"regular\" ]Windows, v3.6.1\n(64-bit)[/button][/column]\n\n[column type=\"one-fourth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lw515\" size=\"regular\" ]Linux, v3.6.1\n(64-bit)[/button][/column]\n\n[column type=\"one-fourth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/ltx4p\" size=\"regular\" ]Mac OSX, v3.6.1\n(64-bit)[/button][/column]\n\n[column type=\"one-fourth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2017-09-19/5dgdc4\" size=\"regular\" ]Tegra X1 v3.5.1\n(64-bit)[/button][/column]\n\n[gap size=\"9%\"]\n\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\n\nLooking for an older installer? <a href=\"https://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"https://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\n[custom_headline type=\"left\" level=\"h2\"]\nGreat. What now?\n[/custom_headline]</p>\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"https://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"https://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"https://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"https://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"https://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\n<p style=\"text-align: left;\">[/content_band]</p>\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-autosave-v1','','','2018-07-26 10:15:21','2018-07-26 14:15:21','',5931,'https://sandbox.arrayfire.com/5931-autosave-v1/',0,'revision','',0),(9470,18672,'2017-02-10 15:38:17','2017-02-10 20:38:17','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/windows-installer\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-x86_64-installer\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/osx-installer\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-armv7l-installer\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2017-02-10 15:38:17','2017-02-10 20:38:17','',5931,'https://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9472,18672,'2017-02-11 00:36:26','2017-02-11 05:36:26','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n<h2>Improvements to the ArrayFire Library</h2>\r\nArrayFire aims to be a portable, high performance scientific computing library. Key areas in ArrayFire can be improved include:\r\n<ul>\r\n 	<li>Improving the performance of existing functions</li>\r\n 	<li>Adding support for more hardware and backends</li>\r\n 	<li>Adding a new domain of functions</li>\r\n</ul>\r\nWith these in mind, we suggest the follow ideas for prospective GSOC17 students.\r\n<h4>IMPLEMENT PARALLEL VERSION OF ARRAYFIRE\'S CPU BACKEND</h4>\r\nThis project focuses on performance improvements to ArrayFire\'s CPU backend. This is done by adding both vectorization and multi-threading support.\r\n\r\nA successful project will implement the following tasks.\r\n<ul>\r\n 	<li>Use existing libraries (MKL, ACML, IPP etc) to accelerate when possible.</li>\r\n 	<li>Use SSE instructions to vectorize key algorithms</li>\r\n 	<li>Use OpenMP to enable multi-threading support.</li>\r\n</ul>\r\n<h4>MACHINE LEARNING ALGORITHMS FOR ARRAYFIRE</h4>\r\nThese algorithms will be written using existing functionality. While no knowledge of CUDA or OpenCL is necessary, familiarity with vectorization concepts is important. A successful project will implement any three of the following tasks using ArrayFire.\r\n<ul>\r\n 	<li>Logistic and Linear regression</li>\r\n 	<li>Expectation Maximization</li>\r\n 	<li>Principal Component Analysis</li>\r\n 	<li>Support Vector Machines</li>\r\n 	<li>Hidden Markov Models</li>\r\n 	<li>Self Organizing Maps</li>\r\n 	<li>Performance improvements to existing Machine Learning algorithms</li>\r\n</ul>\r\n<h3>COMPUTER VISION ALGORITHMS FOR ARRAYFIRE</h3>\r\nThese algorithms will be written in CUDA or OpenCL, along with a CPU implementation (serial), using ArrayFire existing functionality when available. A successful project will implement any one of the following tasks in CUDA or OpenCL plus a CPU implementation in C++:\r\n<ul>\r\n 	<li>SURF</li>\r\n 	<li><a href=\"http://personal.ee.surrey.ac.uk/Personal/Z.Kalal/tld.html\">Tracking-Learning-Detection</a> (TLD)</li>\r\n 	<li><a href=\"http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html\">Accelerated-KAZE Features</a> (AKAZE)</li>\r\n</ul>\r\n<h2>Language Bindings for ArrayFire</h2>\r\nThere are a lot of Scientists and Engineers using higher level languages for scientific computing. ArrayFire\'s C API allows us to write wrappers for high level languages fairly easily. GSOC students can pick a language of their choice and wrap ArrayFire in that language. Our suggestions include the following.\r\n<h4>JAVA WRAPPER FOR ARRAYFIRE</h4>\r\nA Java wrapper already exists for ArrayFire. However it does not have feature parity with the C/C++ version. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux, Windows and OSX</li>\r\n 	<li>Write two new examples demonstrating the wrapper</li>\r\n</ul>\r\n<h4>R WRAPPER FOR ARRAYFIRE</h4>\r\nAs with the Java wrapper, the R wrapper does not have feature parity. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux and OSX</li>\r\n 	<li>Benchmark ArrayFire\'s algorithms with standard implementations in R</li>\r\n</ul>\r\n<h4>OTHER LANGUAGE WRAPPERS</h4>\r\nSuggested languages include: C#, lua and rust. If you prefer a different language, contact us. A successful project will implement the following.\r\n<ul>\r\n 	<li>implement functions from <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/algorithm.h\">arith.h</a>, <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/arith.h\">algorithm.h</a> and <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/blas.h\">blas.h</a></li>\r\n 	<li>Test the wrapper on Linux</li>\r\n 	<li>Write at least one example demonstrating the wrapper</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-11 00:36:26','2017-02-11 05:36:26','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9473,18672,'2017-02-11 00:37:33','2017-02-11 05:37:33','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n<h2>Improvements to the ArrayFire Library</h2>\r\nArrayFire aims to be a portable, high performance scientific computing library. Key areas in ArrayFire can be improved include:\r\n<ul>\r\n 	<li>Improving the performance of existing functions</li>\r\n 	<li>Adding support for more hardware and backends</li>\r\n 	<li>Adding a new domain of functions</li>\r\n</ul>\r\nWith these in mind, we suggest the follow ideas for prospective GSOC17 students.\r\n<b>IMPLEMENT PARALLEL VERSION OF ARRAYFIRE\'S CPU BACKEND</b>\r\nThis project focuses on performance improvements to ArrayFire\'s CPU backend. This is done by adding both vectorization and multi-threading support.\r\n\r\nA successful project will implement the following tasks.\r\n<ul>\r\n 	<li>Use existing libraries (MKL, ACML, IPP etc) to accelerate when possible.</li>\r\n 	<li>Use SSE instructions to vectorize key algorithms</li>\r\n 	<li>Use OpenMP to enable multi-threading support.</li>\r\n</ul>\r\n<h4>MACHINE LEARNING ALGORITHMS FOR ARRAYFIRE</h4>\r\nThese algorithms will be written using existing functionality. While no knowledge of CUDA or OpenCL is necessary, familiarity with vectorization concepts is important. A successful project will implement any three of the following tasks using ArrayFire.\r\n<ul>\r\n 	<li>Logistic and Linear regression</li>\r\n 	<li>Expectation Maximization</li>\r\n 	<li>Principal Component Analysis</li>\r\n 	<li>Support Vector Machines</li>\r\n 	<li>Hidden Markov Models</li>\r\n 	<li>Self Organizing Maps</li>\r\n 	<li>Performance improvements to existing Machine Learning algorithms</li>\r\n</ul>\r\n<b>COMPUTER VISION ALGORITHMS FOR ARRAYFIRE</b>\r\nThese algorithms will be written in CUDA or OpenCL, along with a CPU implementation (serial), using ArrayFire existing functionality when available. A successful project will implement any one of the following tasks in CUDA or OpenCL plus a CPU implementation in C++:\r\n<ul>\r\n 	<li>SURF</li>\r\n 	<li><a href=\"http://personal.ee.surrey.ac.uk/Personal/Z.Kalal/tld.html\">Tracking-Learning-Detection</a> (TLD)</li>\r\n 	<li><a href=\"http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html\">Accelerated-KAZE Features</a> (AKAZE)</li>\r\n</ul>\r\n<h2>Language Bindings for ArrayFire</h2>\r\nThere are a lot of Scientists and Engineers using higher level languages for scientific computing. ArrayFire\'s C API allows us to write wrappers for high level languages fairly easily. GSOC students can pick a language of their choice and wrap ArrayFire in that language. Our suggestions include the following.\r\n<b>JAVA WRAPPER FOR ARRAYFIRE</b>\r\nA Java wrapper already exists for ArrayFire. However it does not have feature parity with the C/C++ version. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux, Windows and OSX</li>\r\n 	<li>Write two new examples demonstrating the wrapper</li>\r\n</ul>\r\n<b>R WRAPPER FOR ARRAYFIRE</b>\r\nAs with the Java wrapper, the R wrapper does not have feature parity. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux and OSX</li>\r\n 	<li>Benchmark ArrayFire\'s algorithms with standard implementations in R</li>\r\n</ul>\r\n<b>OTHER LANGUAGE WRAPPERS</b>\r\nSuggested languages include: C#, lua and rust. If you prefer a different language, contact us. A successful project will implement the following.\r\n<ul>\r\n 	<li>implement functions from <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/algorithm.h\">arith.h</a>, <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/arith.h\">algorithm.h</a> and <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/blas.h\">blas.h</a></li>\r\n 	<li>Test the wrapper on Linux</li>\r\n 	<li>Write at least one example demonstrating the wrapper</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-11 00:37:33','2017-02-11 05:37:33','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9474,18672,'2017-02-11 00:38:39','2017-02-11 05:38:39','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n<h2>Improvements to the ArrayFire Library</h2>\r\nArrayFire aims to be a portable, high performance scientific computing library. Key areas in ArrayFire can be improved include:\r\n<ul>\r\n 	<li>Improving the performance of existing functions</li>\r\n 	<li>Adding support for more hardware and backends</li>\r\n 	<li>Adding a new domain of functions</li>\r\n</ul>\r\nWith these in mind, we suggest the follow ideas for prospective GSOC17 students.\r\n<h5>IMPLEMENT PARALLEL VERSION OF ARRAYFIRE\'S CPU BACKEND</h5>\r\nThis project focuses on performance improvements to ArrayFire\'s CPU backend. This is done by adding both vectorization and multi-threading support.\r\n\r\nA successful project will implement the following tasks.\r\n<ul>\r\n 	<li>Use existing libraries (MKL, ACML, IPP etc) to accelerate when possible.</li>\r\n 	<li>Use SSE instructions to vectorize key algorithms</li>\r\n 	<li>Use OpenMP to enable multi-threading support.</li>\r\n</ul>\r\n<h5>MACHINE LEARNING ALGORITHMS FOR ARRAYFIRE</h5>\r\nThese algorithms will be written using existing functionality. While no knowledge of CUDA or OpenCL is necessary, familiarity with vectorization concepts is important. A successful project will implement any three of the following tasks using ArrayFire.\r\n<ul>\r\n 	<li>Logistic and Linear regression</li>\r\n 	<li>Expectation Maximization</li>\r\n 	<li>Principal Component Analysis</li>\r\n 	<li>Support Vector Machines</li>\r\n 	<li>Hidden Markov Models</li>\r\n 	<li>Self Organizing Maps</li>\r\n 	<li>Performance improvements to existing Machine Learning algorithms</li>\r\n</ul>\r\n<h5>COMPUTER VISION ALGORITHMS FOR ARRAYFIRE</h5>\r\nThese algorithms will be written in CUDA or OpenCL, along with a CPU implementation (serial), using ArrayFire existing functionality when available. A successful project will implement any one of the following tasks in CUDA or OpenCL plus a CPU implementation in C++:\r\n<ul>\r\n 	<li>SURF</li>\r\n 	<li><a href=\"http://personal.ee.surrey.ac.uk/Personal/Z.Kalal/tld.html\">Tracking-Learning-Detection</a> (TLD)</li>\r\n 	<li><a href=\"http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html\">Accelerated-KAZE Features</a> (AKAZE)</li>\r\n</ul>\r\n<h5>Language Bindings for ArrayFire</h5>\r\nThere are a lot of Scientists and Engineers using higher level languages for scientific computing. ArrayFire\'s C API allows us to write wrappers for high level languages fairly easily. GSOC students can pick a language of their choice and wrap ArrayFire in that language. Our suggestions include the following.\r\n\r\n<h5>JAVA WRAPPER FOR ARRAYFIRE</h5>\r\nA Java wrapper already exists for ArrayFire. However it does not have feature parity with the C/C++ version. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux, Windows and OSX</li>\r\n 	<li>Write two new examples demonstrating the wrapper</li>\r\n</ul>\r\n\r\n<h5>R WRAPPER FOR ARRAYFIRE</h5>\r\nAs with the Java wrapper, the R wrapper does not have feature parity. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux and OSX</li>\r\n 	<li>Benchmark ArrayFire\'s algorithms with standard implementations in R</li>\r\n</ul>\r\n\r\n<h5>OTHER LANGUAGE WRAPPERS</h5>\r\nSuggested languages include: C#, lua and rust. If you prefer a different language, contact us. A successful project will implement the following.\r\n<ul>\r\n 	<li>implement functions from <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/algorithm.h\">arith.h</a>, <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/arith.h\">algorithm.h</a> and <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/blas.h\">blas.h</a></li>\r\n 	<li>Test the wrapper on Linux</li>\r\n 	<li>Write at least one example demonstrating the wrapper</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-11 00:38:39','2017-02-11 05:38:39','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9475,18672,'2017-02-11 00:40:36','2017-02-11 05:40:36','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n<h2>Improvements to the ArrayFire Library</h2>\r\nArrayFire aims to be a portable, high performance scientific computing library. Key areas in ArrayFire can be improved include:\r\n<ul>\r\n 	<li>Improving the performance of existing functions</li>\r\n 	<li>Adding support for more hardware and backends</li>\r\n 	<li>Adding a new domain of functions</li>\r\n</ul>\r\nWith these in mind, we suggest the follow ideas for prospective GSOC17 students.\r\n<h6>IMPLEMENT PARALLEL VERSION OF ARRAYFIRE\'S CPU BACKEND</h6>\r\nThis project focuses on performance improvements to ArrayFire\'s CPU backend. This is done by adding both vectorization and multi-threading support.\r\n\r\nA successful project will implement the following tasks.\r\n<ul>\r\n 	<li>Use existing libraries (MKL, ACML, IPP etc) to accelerate when possible.</li>\r\n 	<li>Use SSE instructions to vectorize key algorithms</li>\r\n 	<li>Use OpenMP to enable multi-threading support.</li>\r\n</ul>\r\n<h6>MACHINE LEARNING ALGORITHMS FOR ARRAYFIRE</h6>\r\nThese algorithms will be written using existing functionality. While no knowledge of CUDA or OpenCL is necessary, familiarity with vectorization concepts is important. A successful project will implement any three of the following tasks using ArrayFire.\r\n<ul>\r\n 	<li>Logistic and Linear regression</li>\r\n 	<li>Expectation Maximization</li>\r\n 	<li>Principal Component Analysis</li>\r\n 	<li>Support Vector Machines</li>\r\n 	<li>Hidden Markov Models</li>\r\n 	<li>Self Organizing Maps</li>\r\n 	<li>Performance improvements to existing Machine Learning algorithms</li>\r\n</ul>\r\n<h6>COMPUTER VISION ALGORITHMS FOR ARRAYFIRE</h6>\r\nThese algorithms will be written in CUDA or OpenCL, along with a CPU implementation (serial), using ArrayFire existing functionality when available. A successful project will implement any one of the following tasks in CUDA or OpenCL plus a CPU implementation in C++:\r\n<ul>\r\n 	<li>SURF</li>\r\n 	<li><a href=\"http://personal.ee.surrey.ac.uk/Personal/Z.Kalal/tld.html\">Tracking-Learning-Detection</a> (TLD)</li>\r\n 	<li><a href=\"http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html\">Accelerated-KAZE Features</a> (AKAZE)</li>\r\n</ul>\r\n<h6>Language Bindings for ArrayFire</h6>\r\nThere are a lot of Scientists and Engineers using higher level languages for scientific computing. ArrayFire\'s C API allows us to write wrappers for high level languages fairly easily. GSOC students can pick a language of their choice and wrap ArrayFire in that language. Our suggestions include the following.\r\n\r\n<h6>JAVA WRAPPER FOR ARRAYFIRE</h6>\r\nA Java wrapper already exists for ArrayFire. However it does not have feature parity with the C/C++ version. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux, Windows and OSX</li>\r\n 	<li>Write two new examples demonstrating the wrapper</li>\r\n</ul>\r\n\r\n<h6>R WRAPPER FOR ARRAYFIRE</h6>\r\nAs with the Java wrapper, the R wrapper does not have feature parity. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux and OSX</li>\r\n 	<li>Benchmark ArrayFire\'s algorithms with standard implementations in R</li>\r\n</ul>\r\n\r\n<h6>OTHER LANGUAGE WRAPPERS</h6>\r\nSuggested languages include: C#, lua and rust. If you prefer a different language, contact us. A successful project will implement the following.\r\n<ul>\r\n 	<li>implement functions from <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/algorithm.h\">arith.h</a>, <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/arith.h\">algorithm.h</a> and <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/blas.h\">blas.h</a></li>\r\n 	<li>Test the wrapper on Linux</li>\r\n 	<li>Write at least one example demonstrating the wrapper</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-11 00:40:36','2017-02-11 05:40:36','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9476,18672,'2017-02-11 00:42:40','2017-02-11 05:42:40','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\n<h3>Improvements to the ArrayFire Library</h3>\nArrayFire aims to be a portable, high performance scientific computing library. Key areas in ArrayFire can be improved include:\n<ul>\n 	<li>Improving the performance of existing functions</li>\n 	<li>Adding support for more hardware and backends</li>\n 	<li>Adding a new domain of functions</li>\n</ul>\nWith these in mind, we suggest the follow ideas for prospective GSOC17 students.\n<h6>IMPLEMENT PARALLEL VERSION OF ARRAYFIRE\'S CPU BACKEND</h6>\nThis project focuses on performance improvements to ArrayFire\'s CPU backend. This is done by adding both vectorization and multi-threading support.\n\nA successful project will implement the following tasks.\n<ul>\n 	<li>Use existing libraries (MKL, ACML, IPP etc) to accelerate when possible.</li>\n 	<li>Use SSE instructions to vectorize key algorithms</li>\n 	<li>Use OpenMP to enable multi-threading support.</li>\n</ul>\n<h6>MACHINE LEARNING ALGORITHMS FOR ARRAYFIRE</h6>\nThese algorithms will be written using existing functionality. While no knowledge of CUDA or OpenCL is necessary, familiarity with vectorization concepts is important. A successful project will implement any three of the following tasks using ArrayFire.\n<ul>\n 	<li>Logistic and Linear regression</li>\n 	<li>Expectation Maximization</li>\n 	<li>Principal Component Analysis</li>\n 	<li>Support Vector Machines</li>\n 	<li>Hidden Markov Models</li>\n 	<li>Self Organizing Maps</li>\n 	<li>Performance improvements to existing Machine Learning algorithms</li>\n</ul>\n<h6>COMPUTER VISION ALGORITHMS FOR ARRAYFIRE</h6>\nThese algorithms will be written in CUDA or OpenCL, along with a CPU implementation (serial), using ArrayFire existing functionality when available. A successful project will implement any one of the following tasks in CUDA or OpenCL plus a CPU implementation in C++:\n<ul>\n 	<li>SURF</li>\n 	<li><a href=\"http://personal.ee.surrey.ac.uk/Personal/Z.Kalal/tld.html\">Tracking-Learning-Detection</a> (TLD)</li>\n 	<li><a href=\"http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html\">Accelerated-KAZE Features</a> (AKAZE)</li>\n</ul>\n<h2>Language Bindings for ArrayFire</h2>\nThere are a lot of Scientists and Engineers using higher level languages for scientific computing. ArrayFire\'s C API allows us to write wrappers for high level languages fairly easily. GSOC students can pick a language of their choice and wrap ArrayFire in that language. Our suggestions include the following.\n<h6>JAVA WRAPPER FOR ARRAYFIRE</h6>\nA Java wrapper already exists for ArrayFire. However it does not have feature parity with the C/C++ version. A successful project will implement the following.\n<ul>\n 	<li>Get feature parity with ArrayFire C/C++</li>\n 	<li>Test the wrapper on Linux, Windows and OSX</li>\n 	<li>Write two new examples demonstrating the wrapper</li>\n</ul>\n<h6>R WRAPPER FOR ARRAYFIRE</h6>\nAs with the Java wrapper, the R wrapper does not have feature parity. A successful project will implement the following.\n<ul>\n 	<li>Get feature parity with ArrayFire C/C++</li>\n 	<li>Test the wrapper on Linux and OSX</li>\n 	<li>Benchmark ArrayFire\'s algorithms with standard implementations in R</li>\n</ul>\n<h6>OTHER LANGUAGE WRAPPERS</h6>\nSuggested languages include: C#, lua and rust. If you prefer a different language, contact us. A successful project will implement the following.\n<ul>\n 	<li>implement functions from <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/algorithm.h\">arith.h</a>, <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/arith.h\">algorithm.h</a> and <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/blas.h\">blas.h</a></li>\n 	<li>Test the wrapper on Linux</li>\n 	<li>Write at least one example demonstrating the wrapper</li>\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-autosave-v1','','','2017-02-11 00:42:40','2017-02-11 05:42:40','',9456,'https://sandbox.arrayfire.com/9456-autosave-v1/',0,'revision','',0),(9477,18672,'2017-02-11 00:41:22','2017-02-11 05:41:22','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n<h2>Improvements to the ArrayFire Library</h2>\r\nArrayFire aims to be a portable, high performance scientific computing library. Key areas in ArrayFire can be improved include:\r\n<ul>\r\n 	<li>Improving the performance of existing functions</li>\r\n 	<li>Adding support for more hardware and backends</li>\r\n 	<li>Adding a new domain of functions</li>\r\n</ul>\r\nWith these in mind, we suggest the follow ideas for prospective GSOC17 students.\r\n<h6>IMPLEMENT PARALLEL VERSION OF ARRAYFIRE\'S CPU BACKEND</h6>\r\nThis project focuses on performance improvements to ArrayFire\'s CPU backend. This is done by adding both vectorization and multi-threading support.\r\n\r\nA successful project will implement the following tasks.\r\n<ul>\r\n 	<li>Use existing libraries (MKL, ACML, IPP etc) to accelerate when possible.</li>\r\n 	<li>Use SSE instructions to vectorize key algorithms</li>\r\n 	<li>Use OpenMP to enable multi-threading support.</li>\r\n</ul>\r\n<h6>MACHINE LEARNING ALGORITHMS FOR ARRAYFIRE</h6>\r\nThese algorithms will be written using existing functionality. While no knowledge of CUDA or OpenCL is necessary, familiarity with vectorization concepts is important. A successful project will implement any three of the following tasks using ArrayFire.\r\n<ul>\r\n 	<li>Logistic and Linear regression</li>\r\n 	<li>Expectation Maximization</li>\r\n 	<li>Principal Component Analysis</li>\r\n 	<li>Support Vector Machines</li>\r\n 	<li>Hidden Markov Models</li>\r\n 	<li>Self Organizing Maps</li>\r\n 	<li>Performance improvements to existing Machine Learning algorithms</li>\r\n</ul>\r\n<h6>COMPUTER VISION ALGORITHMS FOR ARRAYFIRE</h6>\r\nThese algorithms will be written in CUDA or OpenCL, along with a CPU implementation (serial), using ArrayFire existing functionality when available. A successful project will implement any one of the following tasks in CUDA or OpenCL plus a CPU implementation in C++:\r\n<ul>\r\n 	<li>SURF</li>\r\n 	<li><a href=\"http://personal.ee.surrey.ac.uk/Personal/Z.Kalal/tld.html\">Tracking-Learning-Detection</a> (TLD)</li>\r\n 	<li><a href=\"http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html\">Accelerated-KAZE Features</a> (AKAZE)</li>\r\n</ul>\r\n<h2>Language Bindings for ArrayFire</h2>\r\nThere are a lot of Scientists and Engineers using higher level languages for scientific computing. ArrayFire\'s C API allows us to write wrappers for high level languages fairly easily. GSOC students can pick a language of their choice and wrap ArrayFire in that language. Our suggestions include the following.\r\n<h6>JAVA WRAPPER FOR ARRAYFIRE</h6>\r\nA Java wrapper already exists for ArrayFire. However it does not have feature parity with the C/C++ version. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux, Windows and OSX</li>\r\n 	<li>Write two new examples demonstrating the wrapper</li>\r\n</ul>\r\n<h6>R WRAPPER FOR ARRAYFIRE</h6>\r\nAs with the Java wrapper, the R wrapper does not have feature parity. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux and OSX</li>\r\n 	<li>Benchmark ArrayFire\'s algorithms with standard implementations in R</li>\r\n</ul>\r\n<h6>OTHER LANGUAGE WRAPPERS</h6>\r\nSuggested languages include: C#, lua and rust. If you prefer a different language, contact us. A successful project will implement the following.\r\n<ul>\r\n 	<li>implement functions from <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/algorithm.h\">arith.h</a>, <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/arith.h\">algorithm.h</a> and <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/blas.h\">blas.h</a></li>\r\n 	<li>Test the wrapper on Linux</li>\r\n 	<li>Write at least one example demonstrating the wrapper</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-11 00:41:22','2017-02-11 05:41:22','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9478,18672,'2017-02-11 00:42:46','2017-02-11 05:42:46','Here are some suggestions for this year\'s Google Summer of Code. This list is not definitive and students may propose their own projects by creating a new topic on the <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire-User Google Group</a> with \"[GSOC]\" in the subject line.\r\n<h3>Improvements to the ArrayFire Library</h3>\r\nArrayFire aims to be a portable, high performance scientific computing library. Key areas in ArrayFire can be improved include:\r\n<ul>\r\n 	<li>Improving the performance of existing functions</li>\r\n 	<li>Adding support for more hardware and backends</li>\r\n 	<li>Adding a new domain of functions</li>\r\n</ul>\r\nWith these in mind, we suggest the follow ideas for prospective GSOC17 students.\r\n<h6>IMPLEMENT PARALLEL VERSION OF ARRAYFIRE\'S CPU BACKEND</h6>\r\nThis project focuses on performance improvements to ArrayFire\'s CPU backend. This is done by adding both vectorization and multi-threading support.\r\n\r\nA successful project will implement the following tasks.\r\n<ul>\r\n 	<li>Use existing libraries (MKL, ACML, IPP etc) to accelerate when possible.</li>\r\n 	<li>Use SSE instructions to vectorize key algorithms</li>\r\n 	<li>Use OpenMP to enable multi-threading support.</li>\r\n</ul>\r\n<h6>MACHINE LEARNING ALGORITHMS FOR ARRAYFIRE</h6>\r\nThese algorithms will be written using existing functionality. While no knowledge of CUDA or OpenCL is necessary, familiarity with vectorization concepts is important. A successful project will implement any three of the following tasks using ArrayFire.\r\n<ul>\r\n 	<li>Logistic and Linear regression</li>\r\n 	<li>Expectation Maximization</li>\r\n 	<li>Principal Component Analysis</li>\r\n 	<li>Support Vector Machines</li>\r\n 	<li>Hidden Markov Models</li>\r\n 	<li>Self Organizing Maps</li>\r\n 	<li>Performance improvements to existing Machine Learning algorithms</li>\r\n</ul>\r\n<h6>COMPUTER VISION ALGORITHMS FOR ARRAYFIRE</h6>\r\nThese algorithms will be written in CUDA or OpenCL, along with a CPU implementation (serial), using ArrayFire existing functionality when available. A successful project will implement any one of the following tasks in CUDA or OpenCL plus a CPU implementation in C++:\r\n<ul>\r\n 	<li>SURF</li>\r\n 	<li><a href=\"http://personal.ee.surrey.ac.uk/Personal/Z.Kalal/tld.html\">Tracking-Learning-Detection</a> (TLD)</li>\r\n 	<li><a href=\"http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html\">Accelerated-KAZE Features</a> (AKAZE)</li>\r\n</ul>\r\n<h3>Language Bindings for ArrayFire</h3>\r\nThere are a lot of Scientists and Engineers using higher level languages for scientific computing. ArrayFire\'s C API allows us to write wrappers for high level languages fairly easily. GSOC students can pick a language of their choice and wrap ArrayFire in that language. Our suggestions include the following.\r\n<h6>JAVA WRAPPER FOR ARRAYFIRE</h6>\r\nA Java wrapper already exists for ArrayFire. However it does not have feature parity with the C/C++ version. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux, Windows and OSX</li>\r\n 	<li>Write two new examples demonstrating the wrapper</li>\r\n</ul>\r\n<h6>R WRAPPER FOR ARRAYFIRE</h6>\r\nAs with the Java wrapper, the R wrapper does not have feature parity. A successful project will implement the following.\r\n<ul>\r\n 	<li>Get feature parity with ArrayFire C/C++</li>\r\n 	<li>Test the wrapper on Linux and OSX</li>\r\n 	<li>Benchmark ArrayFire\'s algorithms with standard implementations in R</li>\r\n</ul>\r\n<h6>OTHER LANGUAGE WRAPPERS</h6>\r\nSuggested languages include: C#, lua and rust. If you prefer a different language, contact us. A successful project will implement the following.\r\n<ul>\r\n 	<li>implement functions from <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/algorithm.h\">arith.h</a>, <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/arith.h\">algorithm.h</a> and <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/blas.h\">blas.h</a></li>\r\n 	<li>Test the wrapper on Linux</li>\r\n 	<li>Write at least one example demonstrating the wrapper</li>\r\n</ul>','GSoC 17 Ideas Page','','inherit','closed','closed','','9456-revision-v1','','','2017-02-11 00:42:46','2017-02-11 05:42:46','',9456,'https://sandbox.arrayfire.com/9456-revision-v1/',0,'revision','',0),(9479,18672,'2017-02-11 00:43:41','2017-02-11 05:43:41','<p>Welcome to ArrayFire\'s home page for GSOC 2015. Please read this document and <a href=\"http://www.google-melange.com/gsoc/document/show/gsoc_program/google/gsoc2014/help_page#1._Are_there_any_age_restrictions_on\">GSOC\'s FAQ</a> before making a proposal. You can contact ArrayFire developers and mentors using our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">mailing list</a> for more information.</p>\r\n\r\n<h2>Information for students</h2>\r\n\r\n<h4>About ArrayFire</h4>\r\n\r\n<p><a href=\"https://github.com/arrayfire/arrayfire\">ArrayFire</a> is a high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple.</p>\r\n\r\n<p>ArrayFire\'s multiple backends (CUDA, OpenCL and native CPU) make it platform independent and highly portable. A few lines of code in ArrayFire can replace dozens of lines of parallel computing code.</p>\r\n\r\n<h4>Requirements</h4>\r\n\r\n<p>While none of the following requirements are mandatory, we do a lot of development in <strong>C</strong> and <strong>C++</strong>. Familiarity with those languages would go a long way in addition to the following domains.</p>\r\n\r\n<ul>\r\n<li>Statistics / Machine Learning tools and libraries (e.g. R, scikit, numpy, etc.)</li>\r\n<li>Image processing and Computer Vision</li>\r\n<li>Experience programming on GPUs (CUDA / OpenCL, or OpenGL / DirectX)</li>\r\n<li>Version Control systems (git)</li>\r\n<li>Or a general interest in scientific computing.</li>\r\n</ul>\r\n\r\n<h4>Guidelines</h4>\r\n\r\n<p>If a project listed here interests you, or if you want to propose a new project, contact the mentors using our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">mailing list</a> with your project proposal.</p>\r\n\r\n<h2>ArrayFire Projects and Ideas</h2>\r\n\r\n<p>We will provide remote access to the hardware relevant to the project if necessary.</p>\r\n\r\n<h4>Improvements to the ArrayFire Library</h4>\r\n\r\n<p><strong>Mentors:</strong> Pavan Yalamanchili, Pradeep Garigipati, Shehzan Mohammed</p>\r\n\r\n<p>ArrayFire aims to be a portable, high performance scientific computing library. Key areas in ArrayFire can be improved include:</p>\r\n\r\n<ul>\r\n<li>Improving the performance of existing functions</li>\r\n<li>Adding support for more hardware and backends</li>\r\n<li>Adding a new domain of functions</li>\r\n</ul>\r\n\r\n<p>With these in mind, we suggest the follow ideas for prospective GSOC15 students.</p>\r\n\r\n<h6>Implement parallel version of ArrayFire\'s CPU backend.</h6>\r\n\r\n<p>This project focuses on performance improvements to ArrayFire\'s CPU backend. This is done by adding both vectorization and multi-threading support.</p>\r\n\r\n<p>A successful project will implement the following tasks.</p>\r\n\r\n<ul>\r\n<li>Use existing libraries (MKL, ACML, IPP etc) to accelerate when possible.</li>\r\n<li>Use SSE instructions to vectorize key algorithms</li>\r\n<li>Use OpenMP to enable multi-threading support.</li>\r\n</ul>\r\n\r\n<h6>Porting ArrayFire OpenCL backend to work on Mobile Platforms</h6>\r\n\r\n<p>ArrayFire\'s OpenCL backend is portable across a variety of OpenCL devices. However it has been developed and tested primarily on desktop GPUs. This project focuses on porting the OpenCL backend to mobile GPUs. Platforms of particular interest include ARM Mali GPUs, and Qualcomm\'s Adreno GPUs. The necessary hardware will be provided by us.</p>\r\n\r\n<p>A successful project will implement the following tasks:</p>\r\n\r\n<ul>\r\n<li>Setup cmake framework to work on ArrayFire for Android devices</li>\r\n<li>Make changes to ArrayFire\'s OpenCL backend to work on mobile devices</li>\r\n<li>Make changes to ArrayFire\'s Java wrapper necessary for Android</li>\r\n</ul>\r\n\r\n<h6>Machine learning algorithms for ArrayFire</h6>\r\n\r\n<p>These algorithms will be written using existing functionality. While no knowledge of CUDA or OpenCL is necessary, familiarity with vectorization concepts important. A successful project will implement any three of the following tasks using ArrayFire.</p>\r\n\r\n<ul>\r\n<li>Logistic and Linear regression</li>\r\n<li>Expectation Maximization </li>\r\n<li>Principal Component Analysis</li>\r\n<li>Support Vector Machines</li>\r\n<li>Hidden Markov Models</li>\r\n<li>Self Organizing Maps</li>\r\n<li>Performance improvements to existing Machine Learning algorithms</li>\r\n</ul>\r\n\r\n<h6>Computer vision algorithms for ArrayFire</h6>\r\n\r\n<p>These algorithms will be written in CUDA or OpenCL, along with a CPU implementation (serial), using ArrayFire existing functionality when available. A successful project will implement any one of the following tasks in CUDA or OpenCL plus a CPU implementation in C++:</p>\r\n\r\n<ul>\r\n<li><a href=\"http://personal.ee.surrey.ac.uk/Personal/Z.Kalal/tld.html\">Tracking-Learning-Detection</a> (TLD)</li>\r\n<li><a href=\"http://www.robesafe.com/personal/pablo.alcantarilla/kaze.html\">Accelerated-KAZE Features</a> (AKAZE)</li>\r\n</ul>\r\n\r\n<h4>Language Bindings for ArrayFire</h4>\r\n\r\n<p>There are a lot of Scientists and Engineers using higher level languages for scientific computing. ArrayFire\'s C API allows us to write wrappers for high level languages fairly easily. GSOC students can pick a language of their choice and wrap ArrayFire in that language. Our suggestions include the following.</p>\r\n\r\n<h6>Java Wrapper for ArrayFire</h6>\r\n\r\n<p>A Java wrapper already exists for ArrayFire. However it does not have feature parity with the C/C++ version. A successful project will implement the following.</p>\r\n\r\n<ul>\r\n<li>Get feature parity with ArrayFire C/C++.</li>\r\n<li>Test the wrapper on Linux, Windows and OSX.</li>\r\n<li>Write two new examples demonstrating the wrapper.</li>\r\n</ul>\r\n\r\n<h6>R wrapper for ArrayFire</h6>\r\n\r\n<p>As with the Java wrapper, the R wrapper does not have feature parity. A successful project will implement the following.</p>\r\n\r\n<ul>\r\n<li>Get feature parity with ArrayFire C/C++</li>\r\n<li>Test the wrapper on Linux and OSX</li>\r\n<li>Benchmark ArrayFire\'s algorithms with standard implementations in R.</li>\r\n</ul>\r\n\r\n<h6>Other language wrappers.</h6>\r\n\r\n<p>Suggested languages include: C#, lua and rust. If you prefer a different language, contact us. A successful project will implement the following.</p>\r\n\r\n<ul>\r\n<li>implement functions from <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/algorithm.h\">arith.h</a>, <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/arith.h\">algorithm.h</a> and <a href=\"https://github.com/arrayfire/arrayfire/blob/devel/include/af/blas.h\">blas.h</a>.</li>\r\n<li>Test the wrapper on Linux.</li>\r\n<li>Write at least one example demonstrating the wrapper.</li>\r\n</ul>\r\n\r\n<h4>The ArrayFire Graphics Library - High performance visualizations</h4>\r\n\r\n<p><strong>Mentors:</strong> Shehzan Mohammed, Pradeep Garigipati</p>\r\n\r\n<p>The ArrayFire Graphics library is a set of visualization API that is targeted towards giving users a range of High performance visualization options.</p>\r\n\r\n<p>The core ideas behind this library are as follows:</p>\r\n\r\n<ul>\r\n<li>Provide a robust, yet flexible, API that allows users to display their data.</li>\r\n<li>Visualization options include, but are not limited to: \r\n\r\n<ul>\r\n<li>Display 2D images</li>\r\n<li>Display 2D and 3D Graphs using lines, points, sprites, surfaces and volumes</li>\r\n<li>Display 3D voxel and voxel-like visualizations</li>\r\n<li>Display 3D geometry</li>\r\n</ul></li>\r\n<li>Allow interop capabilities for both CUDA and OpenCL. This is essential as copying data from GPU to CPU and back to GPU for rendering is a whole lot of waste of performance.</li>\r\n<li>Provide a set of useful keyboard and mouse interaction options.</li>\r\n</ul>\r\n\r\n<h6>Suggested ideas for GSOC15 for this project include:</h6>\r\n\r\n<p>A successful project will include any one of the following:</p>\r\n\r\n<ul>\r\n<li>Create new visualization API. 2D Sprites based UI, 3D voxels, 3D graphs, and 3D geometry are favorites.</li>\r\n<li>Performance improvements to existing API. This includes \r\n\r\n<ul>\r\n<li>improvements to OpenGL code.</li>\r\n<li>data copy performance in ArrayFire.</li>\r\n</ul></li>\r\n<li>Using multi-threading to run OpenGL on an independent thread.</li>\r\n<li>Porting the library to OpenGL ES and/or WebGL.</li>\r\n</ul>\r\n\r\n<h6>Requirements for these project are as follows:</h6>\r\n\r\n<ul>\r\n<li>Extremely good knowledge of OpenGL, GLFW.</li>\r\n<li>Experience with 3D Rendering using OpenGL.</li>\r\n<li>Strong understanding of CUDA-OpenGL and/or OpenCL-OpenGL interop.</li>\r\n<li>Knowledge of game and/or rendering engines is a bonus.</li>\r\n</ul>\r\n','Google Summer Of Code 2015','','inherit','closed','closed','','7812-autosave-v1','','','2017-02-11 00:43:41','2017-02-11 05:43:41','',7812,'https://sandbox.arrayfire.com/7812-autosave-v1/',0,'revision','',0),(9481,18672,'2017-02-13 11:28:31','2017-02-13 16:28:31','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/windows-installer\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-x86_64-installer\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/ltx4p\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-armv7l-installer\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2017-02-13 11:28:31','2017-02-13 16:28:31','',5931,'https://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9482,18672,'2017-02-13 11:40:30','2017-02-13 16:40:30','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lvvyk\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-x86_64-installer\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/ltx4p\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-armv7l-installer\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2017-02-13 11:40:30','2017-02-13 16:40:30','',5931,'https://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9483,18672,'2017-02-13 11:50:28','2017-02-13 16:50:28','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lvvyk\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lw515\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/ltx4p\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://go.sandbox.arrayfire.com/linux-armv7l-installer\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2017-02-13 11:50:28','2017-02-13 16:50:28','',5931,'https://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9484,18672,'2017-02-13 11:51:27','2017-02-13 16:51:27','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nArrayFire Installers\r\n[/custom_headline]\r\n[custom_headline type=\"left\" level=\"h5\"]\r\nEach download contains both CUDA and OpenCL files.\r\n[/custom_headline]\r\n[gap size=\"4%\"]\r\n\r\n[column type=\"one-fifth\"][button  block=\"true\" onclick=\"&lt;!-- Google Code for ArrayFire Download (Windows) Conversion Page\r\nIn your html page, add the snippet and call\r\ngoog_report_conversion when someone clicks on the\r\nchosen link or button. --&gt;\r\n&lt;script type=\"text/javascript\"&gt;\r\n/* &lt;!&amp;#91;CDATA&amp;#91; */\r\ngoog_snippet_vars = function() {\r\nvar w = window;\r\nw.google_conversion_id = 1021026651;\r\nw.google_conversion_label = \"18VJCJjPql4Q28Lu5gM\";\r\nw.google_remarketing_only = false;\r\n}\r\n// DO NOT CHANGE THE CODE BELOW.\r\ngoog_report_conversion = function(url) {\r\ngoog_snippet_vars();\r\nwindow.google_conversion_format = \"3\";\r\nwindow.google_is_call = true;\r\nvar opt = new Object();\r\nopt.onload_callback = function() {\r\nif (typeof(url) != \'undefined\') {\r\nwindow.location = url;\r\n}\r\n}\r\nvar conv_handler = window&amp;#91;\'google_trackConversion\'&amp;#93;;\r\nif (typeof(conv_handler) == \'function\') {\r\nconv_handler(opt);\r\n}\r\n}\r\n/* &amp;#93;&amp;#93;&gt; */\r\n&lt;/script&gt;\r\n&lt;script type=\"text/javascript\"\r\nsrc=\"//www.googleadservices.com/pagead/conversion_async.js\"&gt;\r\n&lt;/script&gt;\" class=\"center-text\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lvvyk\" size=\"regular\" ]Windows, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lw515\" size=\"regular\" ]Linux, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/ltx4p\" size=\"regular\" ]Mac OSX, v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"http://sandbox.arrayfire.com/installer_archive/3.4.2/ArrayFire-v3.4.2_Linux_aarch64.sh\" size=\"regular\" ]Tegra X1 v3.4.2\r\n(64-bit)[/button][/column][column type=\"one-fifth\" last=\"true\"][button block=\"true\" type=\"flat\" shape=\"rounded\" href=\"https://go.pardot.com/l/37882/2015-03-19/lw51f\" size=\"regular\"]Tegra K1 v3.4.2\r\n(32-bit)[/button][/column][gap size=\"9%\"]\r\n\r\nCheck out our GitHub repository to <a href=\"https://github.com/arrayfire/arrayfire\">build from the source</a>.\r\n\r\nLooking for an older installer? <a href=\"http://sandbox.arrayfire.com/installer_archive\">Try here</a>.[/content_band]\r\n<p style=\"text-align: left;\">[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" bg_color=\"#f1f1f1\"][column type=\"one-half\"][gap size=\"8%\"]<img class=\"aligncenter wp-image-5156\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/mobile_Exported1-e1395437261846.png\" alt=\"mobile_Exported\" width=\"233\" height=\"311\" />[/column][column type=\"one-half\" last=\"true\"]\r\n[custom_headline type=\"left\" level=\"h2\"]\r\nGreat. What now?\r\n[/custom_headline]</p>\r\n<p style=\"text-align: left;\">[gap size=\"5%\"]</p>\r\n<p style=\"text-align: left;\">Welcome to ArrayFire! You\'ve got an awesome library there—learn more about its features and functions on <a href=\"http://www.sandbox.arrayfire.com/docs/index.htm\">our documentation</a>.</p>\r\n<p style=\"text-align: left;\">In addition to our <a href=\"https://groups.google.com/forum/#!forum/arrayfire-users\">ArrayFire user group</a> and <a href=\"http://sandbox.arrayfire.com/blog/\">our blog</a>, we offer a plethora of <a href=\"http://sandbox.arrayfire.com/support/\">support options</a> to fit your needs.</p>\r\n<p style=\"text-align: left;\">Got a job that needs closer attention? Hire us! Our engineers are acceleration wizards. Check out our <a href=\"http://sandbox.arrayfire.com/consulting/\">consulting offerings</a>, or set up a free <a href=\"http://meetme.so/arrayfire\">technical consultation</a> with us today![/column]</p>\r\n<p style=\"text-align: left;\">[/content_band]</p>\r\n<p style=\"text-align: center;\"></p>','Download','','inherit','closed','closed','','5931-revision-v1','','','2017-02-13 11:51:27','2017-02-13 16:51:27','',5931,'https://sandbox.arrayfire.com/5931-revision-v1/',0,'revision','',0),(9487,1,'2017-03-06 17:12:07','2017-03-06 22:12:07','','Order &ndash; March 6, 2017 @ 05:12 PM','','wc-completed','open','closed','order_58bddeb47a754','order-mar-06-2017-1012-pm','','','2017-03-06 17:12:11','2017-03-06 22:12:11','',0,'https://sandbox.arrayfire.com/?post_type=shop_order&#038;p=9487',0,'shop_order','',3),(9489,1,'2017-04-03 12:21:03','2017-04-03 16:21:03','','Order &ndash; April 3, 2017 @ 12:21 PM','','wc-completed','open','closed','order_58e2766dd6c0b','order-apr-03-2017-0421-pm','','','2017-04-03 12:21:08','2017-04-03 16:21:08','',0,'https://sandbox.arrayfire.com/?post_type=shop_order&#038;p=9489',0,'shop_order','',3),(9492,6,'2017-04-27 20:03:23','2017-04-28 00:03:23','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]CUDA &amp; OpenCL Training[/custom_headline]\r\n\r\nArrayFire offers up to four days of specialized GPU training in CUDA and OpenCL programming. Attendees will receive the latest industry knowledge and techniques for GPU computing in CUDA and OpenCL.\r\n\r\nWe provide customized on-site training courses. We can travel to your location and provide a CUDA or OpenCL training course tailored to meet your application-specific needs. We also offer trainings at our Atlanta office.\r\n\r\nWe recommend that attendees have a working knowledge of C/C++ in order to gain the most from the training courses.\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us about a training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"https://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"https://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Go ahead, contact us about a training[/button]\r\n\r\n[/column][/content_band]\r\n\r\n[content_band bg_image=\"https://sandbox.arrayfire.com/wp-content/uploads/2014/11/Epipheo-background1.png\" parallax=\"true\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[blockquote cite=\"<span style=\"color: #ffffff;\">Brian Rapp</span>\" type=\"center\"]<span style=\"color: #ffffff;\">One can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','CUDA/OpenCL Training','','publish','closed','closed','','training-cudaopencl','','','2018-06-26 15:47:56','2018-06-26 19:47:56','',0,'https://sandbox.arrayfire.com/?page_id=9492',0,'page','',0),(9493,6,'2017-04-27 16:50:14','2017-04-27 20:50:14','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]CUDA &amp; OpenCL Training[/custom_headline] Attendees will receive the latest industry knowledge and techniques for GPU computing in CUDA and OpenCL.\r\n\r\nArrayFire offers up to four days of specialized GPU training in CUDA and OpenCL programming. We provide customized on-site training courses for customers that have 3 or more attendees from their organization. We can travel to your location and provide a CUDA or OpenCL training course tailored to meet your application-specific needs. We also offer individual trainings at our Atlanta office.\r\n\r\nWe recommend that attendees have a working knowledge of C/C++ in order to gain the most from the training courses.\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us about a training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Go ahead, contact us about a training[/button]\r\n\r\n[/column][/content_band]\r\n\r\n[content_band bg_image=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/11/Epipheo-background1.png\" parallax=\"true\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[blockquote cite=\"<span style=\"color: #ffffff;\">Brian Rapp</span>\" type=\"center\"]<span style=\"color: #ffffff;\">One can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','CUDA/OpenCL Training','','inherit','closed','closed','','9492-revision-v1','','','2017-04-27 16:50:14','2017-04-27 20:50:14','',9492,'https://sandbox.arrayfire.com/9492-revision-v1/',0,'revision','',0),(9494,6,'2017-04-27 20:05:17','2017-04-28 00:05:17','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire is the exclusive Xilinx SDAccel™ Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"https://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />[custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price and Scheduling</strong> – Contact ArrayFire for quote and scheduling (Xilinx training credits accepted)\r\n\r\n<strong>Who Should Attend? </strong>– Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment\r\n\r\n<strong>Prerequisites </strong>–<strong> </strong>Basic knowledge of C/C++\r\n\r\n<strong>Software Tools </strong>–<strong> </strong>SDAccel development environment and common build tools\r\n\r\n<strong>Hardware </strong>–<strong> </strong>Architecture: 7 series, UltraScale, UltraScale+\r\n\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"https://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]<span style=\"color: #ffffff;\">n\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on </span>[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Course Outline[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1[/custom_headline]\r\n<ul>\r\n 	<li>Introduction to OpenCL</li>\r\n 	<li>Comparison of CPU, GPU, and FPGA Architectures</li>\r\n 	<li>OpenCL Support for Xilinx FPGAs</li>\r\n 	<li>FPGA Hardware Details</li>\r\n 	<li>Introduction to the OpenCL API</li>\r\n 	<li><strong>Lab 1: </strong>Creating an OpenCL Program from Scratch</li>\r\n 	<li>OpenCL Execution Model</li>\r\n 	<li><strong>Lab 2: </strong>Vector Addition</li>\r\n 	<li>Memory Hierarchy</li>\r\n 	<li>Profiling and Debugging</li>\r\n 	<li><strong>Lab 3</strong>: Pi by Monte Carlo Processes</li>\r\n 	<li>Optimization</li>\r\n 	<li><strong>Lab 4</strong>: Maximizing Performance</li>\r\n 	<li><strong>Lab 5</strong>: Optimizing Kernels</li>\r\n</ul>\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2[/custom_headline]\r\n<ul>\r\n 	<li>Using the SDAccel Development Environment: Coding, Compiling, Emulating, Profiling, and Debugging</li>\r\n 	<li><strong>Lab 6</strong>: Profiling and Debugging Using the SDAccel Development Environment GUI</li>\r\n 	<li>Using Existing C/C++ Code as Kernels in OpenCL</li>\r\n 	<li><strong>Lab 7</strong>: Optimizing C/C++ Code for OpenCL</li>\r\n 	<li>RTL IP as Kernels in OpenCL</li>\r\n 	<li><strong>Lab 8</strong>: Using an RTL Kernel</li>\r\n</ul>\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Lab Descriptions[/custom_headline]\r\n<ul>\r\n 	<li><strong>Lab 1: </strong>Creating an OpenCL Program from Scratch – Provides an overview of OpenCL API, memory transfers, and kernel enqueuer operations.</li>\r\n 	<li><strong>Lab 2: </strong>Vector Addition – Learn how to execute parallel kernels.</li>\r\n 	<li><strong>Lab 3</strong>: Pi by Monte Carlo Processes – Implement the Pi by Monte Carlo processes.</li>\r\n 	<li><strong>Lab 4</strong>: Maximizing Performance – Use vector data types and increase bandwidth.</li>\r\n 	<li><strong>Lab 5</strong>: Optimizing Kernels – Use Loop Unrolling and Loop Pipelining.</li>\r\n 	<li><strong>Lab 6</strong>: Profiling and Debugging Using the SDAccel Development Environment GUI – Learn how to use interactive programming tools to improve performance and squash bugs.</li>\r\n 	<li><strong>Lab 7</strong>: Optimizing C/C++ Code for OpenCL – Convert existing C/C++ code into a kernel that can be used by OpenCL</li>\r\n 	<li><strong>Lab 8</strong>: Using an RTL Kernel – Learn how to use existing, highly optimized IP in a new OpenCL application.</li>\r\n</ul>\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now register</em>[/button][/column][/content_band]','Xilinx SDAccel Training','','publish','closed','closed','','training-xilinx','','','2018-06-26 15:48:39','2018-06-26 19:48:39','',0,'https://sandbox.arrayfire.com/?page_id=9494',0,'page','',0),(9495,6,'2017-04-27 17:25:05','2017-04-27 21:25:05','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\nCourse Name:  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\nCourse Description:  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\nCourse Duration – 2 days\r\nPrice: Contact ArrayFire for quote at sales@arrayfire.com\r\nWho Should Attend? – Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\nPrerequisites\r\n Basic knowledge of C/C++\r\nSoftware Tools\r\n SDAccel development environment and common build tools\r\nHardware\r\n Architecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:25:05','2017-04-27 21:25:05','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9496,6,'2017-04-27 17:34:08','2017-04-27 21:34:08','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n&lt;ul&gt;Basic knowledge of C/C++\r\n<strong>Software Tools</strong>\r\n&lt;ul&gt;SDAccel development environment and common build tools\r\n<strong>Hardware</strong>\r\n&lt;ul&gt;Architecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:34:08','2017-04-27 21:34:08','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9497,6,'2017-04-27 17:35:00','2017-04-27 21:35:00','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n&lt;ul&gt;Basic knowledge of C/C++&lt;ul&gt;\r\n<strong>Software Tools</strong>\r\n&lt;ul&gt;SDAccel development environment and common build tools&lt;ul&gt;\r\n<strong>Hardware</strong>\r\n&lt;ul&gt;Architecture: 7 series, UltraScale, UltraScale+&lt;ul&gt;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:35:00','2017-04-27 21:35:00','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9498,6,'2017-04-27 17:38:10','2017-04-27 21:38:10','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n<li>Basic knowledge of C/C++<li>\r\n<strong>Software Tools</strong>\r\n<li>SDAccel development environment and common build tools<li>\r\n<strong>Hardware</strong>\r\n<li>Architecture: 7 series, UltraScale, UltraScale+<li>\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:38:10','2017-04-27 21:38:10','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9499,6,'2017-04-27 17:38:59','2017-04-27 21:38:59','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n<li>Basic knowledge of C/C++</li>\r\n<strong>Software Tools</strong>\r\n<li>SDAccel development environment and common build tools</li>\r\n<strong>Hardware</strong>\r\n<li>Architecture: 7 series, UltraScale, UltraScale+</li>\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:38:59','2017-04-27 21:38:59','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9500,6,'2017-04-27 17:42:27','2017-04-27 21:42:27','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Basic knowledge of C/C++[/icon_list_item]\r\n<strong>Software Tools</strong>\r\n<li>SDAccel development environment and common build tools</li>\r\n<strong>Hardware</strong>\r\n<li>Architecture: 7 series, UltraScale, UltraScale+</li>\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:42:27','2017-04-27 21:42:27','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9501,6,'2017-04-27 17:43:35','2017-04-27 21:43:35','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Basic knowledge of C/C++[/icon_list_item]\r\n<strong>Software Tools</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]SDAccel development environment and common build tools[/icon_list_item]\r\n<strong>Hardware</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Architecture: 7 series, UltraScale, UltraScale+[/icon_list_item]\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:43:35','2017-04-27 21:43:35','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9502,6,'2017-04-27 17:44:09','2017-04-27 21:44:09','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n[icon_list_item type=\"angle-double-right\"]Basic knowledge of C/C++[/icon_list_item]\r\n<strong>Software Tools</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]SDAccel development environment and common build tools[/icon_list_item]\r\n<strong>Hardware</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Architecture: 7 series, UltraScale, UltraScale+[/icon_list_item]\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:44:09','2017-04-27 21:44:09','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9503,6,'2017-04-27 17:44:53','2017-04-27 21:44:53','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n[icon_list_item type=\"angle-single-right\"]Basic knowledge of C/C++[/icon_list_item]\r\n<strong>Software Tools</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]SDAccel development environment and common build tools[/icon_list_item]\r\n<strong>Hardware</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Architecture: 7 series, UltraScale, UltraScale+[/icon_list_item]\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:44:53','2017-04-27 21:44:53','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9504,6,'2017-04-27 17:45:30','2017-04-27 21:45:30','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++[/icon_list_item]\r\n<strong>Software Tools</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]SDAccel development environment and common build tools[/icon_list_item]\r\n<strong>Hardware</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Architecture: 7 series, UltraScale, UltraScale+[/icon_list_item]\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:45:30','2017-04-27 21:45:30','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9505,6,'2017-04-27 17:48:04','2017-04-27 21:48:04','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n[icon_list_item type=\"angle-double-right\"]Basic knowledge of C/C++[/icon_list_item]\r\n<strong>Software Tools</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]SDAccel development environment and common build tools[/icon_list_item]\r\n<strong>Hardware</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Architecture: 7 series, UltraScale, UltraScale+[/icon_list_item]\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n&nbsp;\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:48:04','2017-04-27 21:48:04','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9506,6,'2017-04-27 17:48:51','2017-04-27 21:48:51','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\n[icon_list_item type=\"angle-double-right\"]Basic knowledge of C/C++[/icon_list_item]\r\n<strong>Software Tools</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]SDAccel development environment and common build tools[/icon_list_item]\r\n<strong>Hardware</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Architecture: 7 series, UltraScale, UltraScale+[/icon_list_item]\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n<span style=\"color: #ffffff;\">an\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:48:51','2017-04-27 21:48:51','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9507,6,'2017-04-27 17:49:21','2017-04-27 21:49:21','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++[/icon_list_item]\r\n<strong>Software Tools</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]SDAccel development environment and common build tools[/icon_list_item]\r\n<strong>Hardware</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Architecture: 7 series, UltraScale, UltraScale+[/icon_list_item]\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:49:21','2017-04-27 21:49:21','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9508,6,'2017-04-27 17:50:46','2017-04-27 21:50:46','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++[/icon_list_item]\r\n<strong>Software Tools</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]SDAccel development environment and common build tools[/icon_list_item]\r\n<strong>Hardware</strong>\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Architecture: 7 series, UltraScale, UltraScale+[/icon_list_item]\r\n\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:50:46','2017-04-27 21:50:46','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9509,6,'2017-04-27 17:55:01','2017-04-27 21:55:01','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course name:</strong>  Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course description:</strong>  Learn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote at sales@arrayfire.com\r\n\r\n<strong>Who Should Attend –</strong>  Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:55:01','2017-04-27 21:55:01','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9510,6,'2017-04-27 17:59:58','2017-04-27 21:59:58','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\n&nbsp;\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course Name </strong>Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend </strong>– Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 17:59:58','2017-04-27 21:59:58','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9511,6,'2017-04-27 18:01:04','2017-04-27 22:01:04','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<strong>Course Name </strong>Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend </strong>– Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:01:04','2017-04-27 22:01:04','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9512,6,'2017-04-27 18:02:28','2017-04-27 22:02:28','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the SDAccel Xilinx Authorized Training Partner (ATP) for North America. Serving in this capacity, we exclusively offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n<strong>Course Name </strong>Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend </strong>– Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:02:28','2017-04-27 22:02:28','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9513,6,'2017-04-27 18:03:19','2017-04-27 22:03:19','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. We offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n<strong>Course Name </strong>Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend </strong>– Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:03:19','2017-04-27 22:03:19','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9514,6,'2017-04-27 18:03:42','2017-04-27 22:03:42','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. We offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n<strong>Course Name </strong>\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend </strong>– Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n&nbsp;\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:03:42','2017-04-27 22:03:42','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9515,6,'2017-04-27 18:04:44','2017-04-27 22:04:44','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. We offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n<strong>Course Name </strong>\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend </strong>– Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n[icon_list] [icon_list_item type=\"angle-double-right\"]Instruction by an excellent and interesting expert[/icon_list_item] [icon_list_item type=\"angle-double-right\"]Hands-on exercises[/icon_list_item][icon_list_item type=\"angle-double-right\"]Use of a laptop with CUDA and OpenCL capable GPUs and CPUs [/icon_list_item] [icon_list_item type=\"angle-double-right\"]Choice of Linux or Windows operating system[/icon_list_item][icon_list_item type=\"angle-double-right\"]Printed manual of lecture material[/icon_list_item][icon_list_item type=\"angle-double-right\"]Electronic copy of programming exercises[/icon_list_item][/icon_list]\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:04:44','2017-04-27 22:04:44','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9516,6,'2017-04-27 18:06:46','2017-04-27 22:06:46','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. We offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n<strong>Course Name </strong>\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n&nbsp;\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:06:46','2017-04-27 22:06:46','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9517,6,'2017-04-27 18:08:26','2017-04-27 22:08:26','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. We offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n<strong>Course Name </strong>\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n&nbsp;\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:08:26','2017-04-27 22:08:26','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9518,6,'2017-04-27 18:09:01','2017-04-27 22:09:01','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. We offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n<strong>Course Name </strong>\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]\r\n\r\n&nbsp;\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:09:01','2017-04-27 22:09:01','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9519,6,'2017-04-27 18:18:24','2017-04-27 22:18:24','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. We offer SDAccel training courses that will enable design teams leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n<strong>Course Name </strong>\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:18:24','2017-04-27 22:18:24','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9520,6,'2017-04-27 18:26:05','2017-04-27 22:26:05','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h2\"]Course Name[/custom_headline]\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:26:05','2017-04-27 22:26:05','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9521,6,'2017-04-27 18:26:26','2017-04-27 22:26:26','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:26:26','2017-04-27 22:26:26','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9522,6,'2017-04-27 18:26:48','2017-04-27 22:26:48','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h6\"]Course Name[/custom_headline]\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:26:48','2017-04-27 22:26:48','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9523,6,'2017-04-27 18:27:07','2017-04-27 22:27:07','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n<strong>Course Description</strong>\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:27:07','2017-04-27 22:27:07','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9524,6,'2017-04-27 18:27:43','2017-04-27 22:27:43','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:27:43','2017-04-27 22:27:43','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9525,6,'2017-04-27 18:28:02','2017-04-27 22:28:02','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]\r\n\r\nDeveloping and Optimizing Applications Using the OpenCL Framework for FPGAs[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:28:02','2017-04-27 22:28:02','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9526,6,'2017-04-27 18:28:25','2017-04-27 22:28:25','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:28:25','2017-04-27 22:28:25','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9527,6,'2017-04-27 18:29:00','2017-04-27 22:29:00','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-third\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:29:00','2017-04-27 22:29:00','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9528,6,'2017-04-27 18:29:19','2017-04-27 22:29:19','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:29:19','2017-04-27 22:29:19','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9529,6,'2017-04-27 18:29:39','2017-04-27 22:29:39','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"5\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:29:39','2017-04-27 22:29:39','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9530,6,'2017-04-27 18:30:25','2017-04-27 22:30:25','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-quarter\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:30:25','2017-04-27 22:30:25','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9531,6,'2017-04-27 18:30:46','2017-04-27 22:30:46','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:30:46','2017-04-27 22:30:46','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9532,6,'2017-04-27 18:31:17','2017-04-27 22:31:17','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:31:17','2017-04-27 22:31:17','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9533,6,'2017-04-27 18:32:59','2017-04-27 22:32:59','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:32:59','2017-04-27 22:32:59','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9534,6,'2017-04-27 18:33:35','2017-04-27 22:33:35','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:33:35','2017-04-27 22:33:35','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),(9535,6,'2017-04-27 18:34:03','2017-04-27 22:34:03','[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][custom_headline type=\"left\" level=\"h2\" ]Xilinx SDAccel Training[/custom_headline]\r\n\r\nArrayFire has been selected as the exclusive SDAccel Xilinx Authorized Training Partner (ATP) for North America. Our SDAccel training courses help enable design teams to leverage Xilinx FPGAs for OpenCL application acceleration.\r\n\r\n<img src=\"http://sandbox.arrayfire.com/wp-content/uploads/2015/05/xilinx_alliance-1024x332.png\" alt=\"xilinx_alliance\" />\r\n\r\n[custom_headline type=\"left\" level=\"h5\"]Course Name[/custom_headline]Developing and Optimizing Applications Using the OpenCL Framework for FPGAs\r\n\r\n[custom_headline type=\"left\" level=\"h5\"]Course Description[/custom_headline]\r\n\r\nLearn how to develop new applications written in OpenCL, C/C++, and RTL in the SDAccel™ development environment for use on Xilinx FPGAs. Porting existing applications is also covered.\r\n\r\nTraining lectures and labs for this course will enable attendees to gain necessary skills to: identify parallel computing applications suitable for accelerating on FPGAs, understand how the FPGA architecture lends itself to parallel computing, write OpenCL programs for FPGAs, and utilize the SDAccel Development Environment.\r\n\r\nThis course also demonstrates how to debug and profile OpenCL code using the SDAccel development environment. In addition, you will also learn how to maximize performance and efficiently utilize FPGA resources.\r\n\r\n<strong>Course Duration</strong> – 2 days\r\n\r\n<strong>Price</strong> – Contact ArrayFire for quote. Xilinx training credits accepted.\r\n\r\n<strong>Who Should Attend?</strong> Software and hardware developers who want to develop OpenCL, C/C++, and RTL applications in the SDAccel development environment.\r\n\r\n<strong>Prerequisites</strong>\r\nBasic knowledge of C/C++\r\n\r\n<strong>Software Tools</strong>\r\nSDAccel development environment and common build tools\r\n\r\n<strong>Hardware</strong>\r\nArchitecture: 7 series, UltraScale, UltraScale+\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Contact us to register for training[/button]\r\n\r\n&nbsp;\r\n\r\n[/column]\r\n\r\n[column type=\"one-half\" last=\"true\" fade=\"true\" fade_animation=\"in-from-right\" class=\"center-text\"][gap size=\"15%\"][image src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/02/Professor-AF_Exported-e1395436350363.png\" ][/column]\r\n\r\n[/content_band][content_band bg_color=\"#F2f2f2\" inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[column type=\"one-half\"][gap size=\"10%\"]<img class=\"aligncenter wp-image-4806\" src=\"http://sandbox.arrayfire.com/wp-content/uploads/2014/01/gears1-e1395437543311.png\" alt=\"gears\" width=\"427\" height=\"400\" />\r\n\r\n[/column][column type=\"one-half\" last=\"true\"]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Included in the course[/custom_headline]\r\n\r\nYou provide the minds, and we\'ll take care of the rest. Each training comes with the following:\r\n\r\n<span style=\"color: #ffffff;\">ne can\'t ask for better individualized instruction than the environment I was fortunate enough to encounter.</span> <span style=\"color: #ffffff;\">The instructor was able to completely focus on my particular needs and concerns.</span>\r\n\r\n<span style=\"color: #ffffff;\">—Brian Rapp,  U.S. Army Research Lab</span>[/blockquote]\r\n\r\n[/content_band]\r\n\r\n[content_band inner_container=\"true\" no_margin=\"true\" border=\"none\" padding_top=\"10px\" padding_bottom=\"40px\" ]\r\n\r\n[custom_headline type=\"left\" level=\"h2\"]Training Syllabus[/custom_headline] [column type=\"one-half\"] [custom_headline type=\"left\" level=\"h5\"  accent=\"false\"]Day 1, Introduction[/custom_headline] Lectures:\r\nGPU Computing Overview\r\nThe Programming Model\r\nBasic Dataset Mapping Techniques\r\nLibraries, ArrayFire\r\nProfiling Tools\r\n\r\nPractice:\r\nA Simple Kernel\r\nEquivalent ArrayFire Example\r\nUsing Libraries\r\nMonte Carlo Pi Estimation\r\nTiming and ArrayFire\r\nDebugging Code\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 3, Multi-GPU[/custom_headline] Lectures (customizable):\r\nMulti-GPU Use Cases\r\nMulti-GPUs: Contexts\r\nExisting Libraries\r\nScaling Across Multiple GPUs\r\n\r\nPractice:\r\nOut of Core Problems: Matrix Multiply\r\nTask Level Parallelism: Optimization\r\nArrayFire Multi-GPU[/column]\r\n\r\n[column type=\"one-half\" last=\"true\"] [custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 2, Optimization[/custom_headline] Lectures:\r\nArchitecture: Grids, Blocks, and Threads\r\nMemory Model: Global, Shared, and Constant Memory\r\nAdvanced Mapping Techniques\r\nStreams: Asynchronos Launches and Concurrent Execution\r\nArrayFire: Lazy Evaluation and Code Vectorization\r\n\r\nPractice:\r\nMatrix Transpose\r\nOptimization Using Shared Memory\r\nMedian Filter\r\nOptimization Using Constant Memory\r\nStream Example\r\nArrayFire Example: Nearest Neighbor Algorithm\r\n\r\n[custom_headline type=\"left\" level=\"h5\" accent=\"false\"]Day 4, Algorithm Problems[/custom_headline]\r\n\r\nLectures and Practice (customizable):\r\nReductions\r\nScan Algorithms\r\nSort\r\nConvolution\r\nCustomer-Specific Problem\r\n\r\n[button type=\"flat\" shape=\"rounded\"  size=\"regular\" href=\"mailto:sales@arrayfire.com?Subject=Training%20Inquiry\"]Okay, <em>now </em>contact us about a training[/button][/column][/content_band]','Xilinx SDAccel Training','','inherit','closed','closed','','9494-revision-v1','','','2017-04-27 18:34:03','2017-04-27 22:34:03','',9494,'https://sandbox.arrayfire.com/9494-revision-v1/',0,'revision','',0),