diff --git a/docs/layout.xml b/docs/layout.xml index 0b272f6..971c00a 100644 --- a/docs/layout.xml +++ b/docs/layout.xml @@ -5,8 +5,6 @@ - - diff --git a/docs/pages/README.md b/docs/pages/README.md index 8a395a7..46011ca 100644 --- a/docs/pages/README.md +++ b/docs/pages/README.md @@ -9,10 +9,8 @@ ArrayFire is a high performance software library for parallel computing with an ## Installing ArrayFire -You can install ArrayFire using either a binary installer for Windows, OSX, -or Linux or download it from source: +You can install ArrayFire using Parabola or download it from source: -* [Binary installers for Windows, OSX, and Linux](\ref installing) * [Build from source](https://github.com/arrayfire/arrayfire) ## Easy to use @@ -24,7 +22,7 @@ readable math-resembling notation. You _do not_ need expertise in parallel programming to use ArrayFire. A few lines of ArrayFire code -accomplishes what can take 100s of complicated lines in CUDA or OpenCL +accomplishes what can take 100s of complicated lines in OpenCL kernels. ## ArrayFire is extensive! @@ -56,25 +54,23 @@ unsigned integers. #### Extending ArrayFire ArrayFire can be used as a stand-alone application or integrated with -existing CUDA or OpenCL code. All ArrayFire `arrays` can be -interchanged with other CUDA or OpenCL data structures. +existing OpenCL code. All ArrayFire `arrays` can be +interchanged with other OpenCL data structure. ## Code once, run anywhere! -With support for x86, ARM, CUDA, and OpenCL devices, ArrayFire supports for a comprehensive list of devices. +With support for x86, ARM, and OpenCL devices, ArrayFire supports for a comprehensive list of devices. Each ArrayFire installation comes with: - - a CUDA version (named 'libafcuda') for [NVIDIA - GPUs](https://developer.nvidia.com/cuda-gpus), - an OpenCL version (named 'libafopencl') for [OpenCL devices](http://www.khronos.org/conformance/adopters/conformant-products#opencl) - - a CPU version (named 'libafcpu') to fall back to when CUDA or OpenCL devices are not available. + - a CPU version (named 'libafcpu') to fall back to when OpenCL devices are not available. ## ArrayFire is highly efficient #### Vectorized and Batched Operations ArrayFire supports batched operations on N-dimensional arrays. -Batch operations in ArrayFire are run in parallel ensuring an optimal usage of your CUDA or OpenCL device. +Batch operations in ArrayFire are run in parallel ensuring an optimal usage of your OpenCL device. You can get the best performance out of ArrayFire using [vectorization techniques](\ref vectorization). @@ -93,7 +89,7 @@ Read more about how [ArrayFire JIT](http://arrayfire.com/performance-of-arrayfir ## Simple Example Here's a live example to let you see ArrayFire code. You create [arrays](\ref construct_mat) -which reside on CUDA or OpenCL devices. Then you can use +which reside on OpenCL devices. Then you can use [ArrayFire functions](modules.htm) on those [arrays](\ref construct_mat). ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp} @@ -144,7 +140,7 @@ Formatted: BibTeX: @misc{Yalamanchili2015, - abstract = {ArrayFire is a high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. 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, saving you valuable time and lowering development costs.}, + abstract = {ArrayFire is a high performance software library for parallel computing with an easy-to-use API. Its array based function set makes parallel programming simple. ArrayFire's multiple backends (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, saving you valuable time and lowering development costs.}, address = {Atlanta}, author = {Yalamanchili, Pavan and Arshad, Umar and Mohammed, Zakiuddin and Garigipati, Pradeep and Entschev, Peter and Kloppenborg, Brian and Malcolm, James and Melonakos, John}, publisher = {AccelerEyes}, diff --git a/docs/pages/configuring_arrayfire_environment.md b/docs/pages/configuring_arrayfire_environment.md index d554046..526d4cc 100644 --- a/docs/pages/configuring_arrayfire_environment.md +++ b/docs/pages/configuring_arrayfire_environment.md @@ -28,19 +28,6 @@ detailed. This helps in locating the exact failure. AF_PRINT_ERRORS=1 ./myprogram ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -AF_CUDA_DEFAULT_DEVICE {#af_cuda_default_device} -------------------------------------------------------------------------------- - -Use this variable to set the default CUDA device. Valid values for this -variable are the device identifiers shown when af::info is run. - -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -AF_CUDA_DEFAULT_DEVICE=1 ./myprogram_cuda -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Note: af::setDevice call in the source code will take precedence over this -variable. - AF_OPENCL_DEFAULT_DEVICE {#af_opencl_default_device} ------------------------------------------------------------------------------- diff --git a/docs/pages/getting_started.md b/docs/pages/getting_started.md index c1ae05e..202baf2 100644 --- a/docs/pages/getting_started.md +++ b/docs/pages/getting_started.md @@ -41,7 +41,6 @@ For example: \snippet test/getting_started.cpp ex_getting_started_init ArrayFire also supports array initialization from a device pointer. -For example ArrayFire can be populated directly by a call to `cudaMemcpy` \snippet test/getting_started.cpp ex_getting_started_dev_ptr @@ -69,7 +68,7 @@ Most of ArrayFire's functions operate on an element-wise basis. This means that function like `c[i] = a[i] + b[i]` could simply be written as `c = a + b`. ArrayFire has an intelligent runtime JIT compliation engine which converts -array expressions into the smallest number of OpenCL/CUDA kernels. +array expressions into the smallest number of OpenCL kernels. This "kernel fusion" technology not only decreases the number of kernel calls, but, more importantly, avoids extraneous global memory operations. Our JIT functionality extends across C/C++ function boundaries and only ends @@ -100,7 +99,7 @@ using the `af::` namespace. # Indexing {#getting_started_indexing} Like all functions in ArrayFire, indexing is also executed in parallel on -the OpenCL/CUDA device. +the OpenCL device. Because of this, indexing becomes part of a JIT operation and is accomplished using parentheses instead of square brackets (i.e. as `A(0)` instead of `A[0]`). To index `af::array`s you may use one or a combination of the following functions: @@ -123,8 +122,8 @@ and device()](\ref af::array::device) functions. The `host` function *copies* the data from the device and makes it available in a C-style array on the host. The `device` function returns a pointer to device memory for interoperability -with external CUDA/OpenCL kernels. -For example, here is how we can interact with both OpenCL and CUDA: +with external OpenCL kernels. +For example, here is how we can interact with OpenCL: \snippet test/getting_started.cpp ex_getting_started_ptr @@ -194,8 +193,7 @@ simply include the `arrayfire.h` header file and start coding! Now that you have a general introduction to ArrayFire, where do you go from here? In particular you might find these documents useful -* [Building an ArrayFire program on Linux](\ref using_on_linux) -* [Building an Arrayfire program on Windows](\ref using_on_windows) +* [Building an ArrayFire program on GNU/Linux](\ref using_on_linux) * [Timing ArrayFire code](\ref timing) diff --git a/docs/pages/release_notes.md b/docs/pages/release_notes.md index 7aa3878..186e183 100644 --- a/docs/pages/release_notes.md +++ b/docs/pages/release_notes.md @@ -433,7 +433,6 @@ v3.1.1 Installers ----------- -* CUDA backend now depends on CUDA 7.5 toolkit * OpenCL backend now require OpenCL 1.2 or greater Bug Fixes @@ -513,10 +512,6 @@ Function Additions * \ref saveArray() and \ref readArray() - Stream arrays to binary files * \ref toString() - toString function returns the array and data as a string -* CUDA specific functionality - * \ref getStream() - Returns default CUDA stream ArrayFire uses for the current device - * \ref getNativeId() - Returns native id of the CUDA device - Improvements ------------ * dot @@ -540,11 +535,6 @@ Improvements * CPU Backend * Device properties for CPU * Improved performance when all buffers are indexed linearly -* CUDA Backend - * Use streams in CUDA (no longer using default stream) - * Using async cudaMem ops - * Add 64-bit integer support for JIT functions - * Performance improvements for CUDA JIT for non-linear 3D and 4D arrays * OpenCL Backend * Improve compilation times for OpenCL backend * Performance improvements for non-linear JIT kernels on OpenCL @@ -578,7 +568,7 @@ New Examples Installer ---------- * Fixed bug in automatic detection of ArrayFire when using with CMake in Windows -* The Linux libraries are now compiled with static version of FreeImage +* The GNU/Linux libraries are now compiled with static version of FreeImage Known Issues ------------ diff --git a/docs/pages/using_on_linux.md b/docs/pages/using_on_linux.md index 493080f..b86c326 100644 --- a/docs/pages/using_on_linux.md +++ b/docs/pages/using_on_linux.md @@ -1,42 +1,35 @@ -Using ArrayFire on Linux {#using_on_linux} +Using ArrayFire on GNU/Linux {#using_on_linux} ===== Once you have [installed](\ref installing) ArrayFire on your system, the next thing to do is -set up your build system. On Linux, you can create ArrayFire projects using +set up your build system. On GNU/Linux, you can create ArrayFire projects using almost any editor, compiler, or build system. The only requirements are that you include the ArrayFire header directories and link with the ArrayFire library you intend to use. ## The big picture -On Linux, we suggest you install ArrayFire to the `/usr/local` directory +On GNU/Linux, we suggest you install ArrayFire to the `/usr/local` directory so that all of the include files and libraries are part of your standard path. The installer will populate files in the following sub-directories: include/arrayfire.h - Primary ArrayFire include file include/af/*.h - Additional include files - lib/libaf* - CPU, CUDA, and OpenCL libraries (.a, .so) + lib/libaf* - CPU and OpenCL libraries (.a, .so) lib/libforge* - Visualization library share/ArrayFire/cmake/* - CMake config (find) scripts share/ArrayFire/examples/* - All ArrayFire examples Because ArrayFire follows standard installation practices, you can use basically any build system to create and compile projects that use ArrayFire. -Among the many possible build systems on Linux we suggest using ArrayFire with +Among the many possible build systems on GNU/Linux we suggest using ArrayFire with either CMake or Makefiles with CMake being our preferred build system. ## Prerequisite software To build ArrayFire projects you will need a compiler -#### Fedora, Centos and Redhat - -Install EPEL repo (not required for Fedora) - -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -yum install epel-release -yum update -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +#### BLAG Linux and GNU Install build dependencies @@ -44,7 +37,7 @@ Install build dependencies yum install gcc gcc-c++ cmake make ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -#### Debian and Ubuntu +#### GnewSense and Trisquel Install common dependencies @@ -64,7 +57,7 @@ ArrayFire to an existing project. As [discussed above](#big-picture), ArrayFire ships with a series of CMake scripts to make finding and using our library easy. The scripts will automatically find all versions of the ArrayFire library -and pick the most powerful of the installed backends (typically CUDA). +and pick the most powerful of the installed backends. First create a file called `CMakeLists.txt` in your project directory: @@ -82,22 +75,13 @@ and populate it with the following code: FIND_PACKAGE(OpenCL) SET(EXTRA_LIBS ${CMAKE_THREAD_LIBS_INIT} ${OpenCL_LIBRARIES}) - # Or if you intend to use CUDA, you need it as well as NVVM: - FIND_PACKAGE(CUDA) - FIND_PACKAGE(NVVM) # this FIND script can be found in the ArrayFire CMake example repository - SET(EXTRA_LIBS ${CMAKE_THREAD_LIBS_INIT} ${CUDA_LIBRARIES} ${NVVM_LIB}) - ADD_EXECUTABLE(my_executable [list your source files here]) TARGET_LINK_LIBRARIES(my_executable ${ArrayFire_LIBRARIES} ${EXTRA_LIBS}) where `my_executable` is the name of the executable you wish to create. See the [CMake documentation](https://cmake.org/documentation/) for more information on how to use CMake. -Clearly the above code snippet precludes the use of both CUDA and OpenCL, see -the -[ArrayFire CMake Example](https://github.com/arrayfire/arrayfire-project-templates/tree/master/CMake); -for an example of how to build executables for both backends from the same -CMake script. +Clearly the above code snippet precludes the use of OpenCL. In the above code listing, the `FIND_PACKAGE` will find the ArrayFire include files, libraries, and define several variables including: @@ -112,8 +96,6 @@ If you wish to use a specific backend, the find script also defines these variab ArrayFire_CPU_FOUND - True of the ArrayFire CPU library has been found. ArrayFire_CPU_LIBRARIES - Location of ArrayFire's CPU library, if found - ArrayFire_CUDA_FOUND - True of the ArrayFire CUDA library has been found. - ArrayFire_CUDA_LIBRARIES - Location of ArrayFire's CUDA library, if found ArrayFire_OpenCL_FOUND - True of the ArrayFire OpenCL library has been found. ArrayFire_OpenCL_LIBRARIES - Location of ArrayFire's OpenCL library, if found ArrayFire_Unified_FOUND - True of the ArrayFire Unified library has been found. @@ -121,13 +103,8 @@ If you wish to use a specific backend, the find script also defines these variab Therefore, if you wish to target a specific specific backend, simply replace `${ArrayFire_LIBRARIES}` with `${ArrayFire_CPU}`, `${ArrayFire_OPENCL}`, -`${ArrayFire_CUDA}`, or `${ArrayFire_Unified}` in the `TARGET_LINK_LIBRARIES` +or `${ArrayFire_Unified}` in the `TARGET_LINK_LIBRARIES` command above. -If you intend on building your software to link with all of these backends, -please see the -[CMake Project Example](https://github.com/arrayfire/arrayfire-project-templates) -which makes use of some fairly fun CMake tricks to avoid re-compiling code -whenever possible. Next we need to instruct CMake to create build instructions and then compile. We suggest using CMake's out-of-source build functionality to keep your build @@ -161,8 +138,7 @@ instructions. Similarly, you will need to specify the path to the ArrayFire library using the `-L` option (e.g. `-L/usr/local/lib`) followed by the specific ArrayFire library you wish to use using the `-l` option (for example `-lafcpu`, -`-lafopencl`, `-lafcuda`, or `-laf` for the CPU, OpenCL, CUDA, and unified -backends respectively. +`-lafopencl`, or `-laf` for the CPU, OpenCL, and unified backends respectively. Here is a minimial example MakeFile which uses ArrayFire's CPU backend: