diff options
| -rw-r--r-- | libre/arrayfire/PKGBUILD | 91 | ||||
| -rw-r--r-- | libre/arrayfire/remove-nonfree-references.patch | 310 |
2 files changed, 401 insertions, 0 deletions
diff --git a/libre/arrayfire/PKGBUILD b/libre/arrayfire/PKGBUILD new file mode 100644 index 000000000..8db884e03 --- /dev/null +++ b/libre/arrayfire/PKGBUILD @@ -0,0 +1,91 @@ +# Maintainer (Arch): Sven-Hendrik Haase <sh@lutzhaase.com> +# Maintainer: André Silva <emulatorman@parabola.nu> +pkgname=arrayfire +pkgdesc="High performance software library for parallel computing with an easy-to-use API, without nonfree cuda and nvidia-utils support and nonfree SIFT algorithm" +url='http://arrayfire.com' +pkgver=3.1.2 +arch=('i686' 'x86_64') +pkgrel=1.parabola1 +license=('BSD') +makedepends=('cmake' 'graphviz' 'doxygen' 'opencl-headers' 'glfw' 'glew' 'boost' 'git') +depends=('cblas' 'fftw' 'boost-libs' 'lapack' 'forge' 'freeimage') +optdepends=('libclc: Required for using OpenCL backend' + 'glfw: Required for running the examples' + 'glew: Required for running the examples') +mksource=(http://arrayfire.com/arrayfire_source/arrayfire-full-${pkgver}.tar.bz2) +source=(https://repo.parabola.nu/other/${pkgname}-libre/${pkgname}-libre-full-${pkgver}.tar.bz2 + remove-nonfree-references.patch) +mkmd5sums=('c60b10a5ad66ca363ab0732fd9438c15') +md5sums=('39c4c2dbb0e0dd7460d357210fee1ead' + 'bb0ef2b34ee09af4c85c9cb13c0ee485') + +check() { + cd "${srcdir}/arrayfire-full-${pkgver}/build" + + #make test +} + +mksource() { + cd "${srcdir}/arrayfire-full-${pkgver}/" + + # remove nonfree SIFT algorithm that is patented in some countries and have some other limitations on the use + rm -v src/backend/cuda/kernel/sift_nonfree.hpp + rm -v src/backend/opencl/kernel/sift_nonfree.cl + rm -v src/backend/opencl/kernel/sift_nonfree.hpp + rm -v src/backend/cpu/sift_nonfree.hpp +} + +prepare() { + cd "${srcdir}/arrayfire-full-${pkgver}/" + + # remove nonfree reference/recommendation stuff + rm -rv CMakeModules/osx_install + rm -rv src/backend/cuda + rm -rv test/data/sift + rm -v CMakeModules/CUDACheckCompute.cmake + rm -v CMakeModules/cuda_compute_capability.cpp + rm -v assets/CUDA.png + rm -v docs/pages/INSTALL.md + rm -v docs/pages/using_on_osx.md + rm -v docs/pages/using_on_windows.md + rm -v include/af/cuda.h + rm -v src/api/cpp/sift.cpp + rm -v src/api/c/sift.cpp + rm -v src/backend/opencl/sift.cpp + rm -v src/backend/opencl/sift.hpp + rm -v src/backend/cpu/sift.cpp + rm -v src/backend/cpu/sift.hpp + rm -v test/sift_nonfree.cpp + patch -Np1 -i "${srcdir}/remove-nonfree-references.patch" +} + +build() { + cd "${srcdir}/arrayfire-full-${pkgver}/" + + rm -rf build + mkdir build && cd build + + cmake .. \ + -DCMAKE_INSTALL_PREFIX=/usr \ + -DUSE_SYSTEM_FORGE=ON \ + -DCOMPUTES_DETECTED_LIST="20;30;32;35;50;52;53" \ + -DBUILD_CPU=ON \ + -DCMAKE_BUILD_TYPE=Release \ + -DBUILD_EXAMPLES=ON \ + -DBUILD_DOCS=ON \ + -DBUILD_NONFREE=OFF \ + -DBUILD_SIFT=OFF \ + -DBUILD_CUDA=OFF + + make +} + +package() { + cd "${srcdir}/arrayfire-full-${pkgver}" + + install -Dm644 LICENSE ${pkgdir}/usr/share/licenses/${pkgname}/LICENSE + + cd build + + make DESTDIR="${pkgdir}/" install +} diff --git a/libre/arrayfire/remove-nonfree-references.patch b/libre/arrayfire/remove-nonfree-references.patch new file mode 100644 index 000000000..743118c7b --- /dev/null +++ b/libre/arrayfire/remove-nonfree-references.patch @@ -0,0 +1,310 @@ +diff -Nur arrayfire-full-3.1.2.orig/docs/layout.xml arrayfire-full-3.1.2/docs/layout.xml +--- arrayfire-full-3.1.2.orig/docs/layout.xml 2015-09-25 19:16:18.000000000 -0300 ++++ arrayfire-full-3.1.2/docs/layout.xml 2015-11-02 17:01:08.145683665 -0300 +@@ -4,8 +4,6 @@ + <tab type="mainpage" visible="yes" title="" /> + <tab type="usergroup" visible="yes" title="Tutorials"> + <tab type="user" url="\ref using_on_linux" visible="yes" title="Using on Linux"/> +- <tab type="user" url="\ref using_on_windows" visible="yes" title="Using on Windows"/> +- <tab type="user" url="\ref using_on_osx" visible="yes" title="Using on OSX"/> + <tab type="user" url="\ref gettingstarted" visible="yes" title="Getting Started"/> + <tab type="user" url="\ref matrixmanipulation" visible="yes" title="Matrix Manipulation"/> + <tab type="user" url="\ref indexing" visible="yes" title="Indexing"/> +diff -Nur arrayfire-full-3.1.2.orig/docs/pages/README.md arrayfire-full-3.1.2/docs/pages/README.md +--- arrayfire-full-3.1.2.orig/docs/pages/README.md 2015-09-25 19:16:18.000000000 -0300 ++++ arrayfire-full-3.1.2/docs/pages/README.md 2015-11-02 15:56:01.952662051 -0300 +@@ -9,10 +9,8 @@ + + ## 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 @@ + 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 @@ + #### 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](). + +@@ -93,7 +89,7 @@ + ## 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 ++construct_mat) which reside on OpenCL devices. Then you can use + [ArrayFire functions](modules.htm) on those [arrays](\ref construct_mat). + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp} +@@ -144,7 +140,7 @@ + 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 -Nur arrayfire-full-3.1.2.orig/docs/pages/configuring_arrayfire_environment.md arrayfire-full-3.1.2/docs/pages/configuring_arrayfire_environment.md +--- arrayfire-full-3.1.2.orig/docs/pages/configuring_arrayfire_environment.md 2015-09-25 19:16:18.000000000 -0300 ++++ arrayfire-full-3.1.2/docs/pages/configuring_arrayfire_environment.md 2015-11-02 12:12:06.817016693 -0300 +@@ -18,19 +18,6 @@ + present in this directory. You can use this variable to add include paths and + libraries to your projects. + +-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 -Nur arrayfire-full-3.1.2.orig/docs/pages/getting_started.md arrayfire-full-3.1.2/docs/pages/getting_started.md +--- arrayfire-full-3.1.2.orig/docs/pages/getting_started.md 2015-09-25 19:16:18.000000000 -0300 ++++ arrayfire-full-3.1.2/docs/pages/getting_started.md 2015-11-02 17:00:05.388864755 -0300 +@@ -39,7 +39,6 @@ + \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 + +@@ -67,7 +66,7 @@ + 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 +@@ -98,7 +97,7 @@ + # 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: +@@ -121,8 +120,8 @@ + 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 + +@@ -192,8 +191,7 @@ + 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 -Nur arrayfire-full-3.1.2.orig/docs/pages/release_notes.md arrayfire-full-3.1.2/docs/pages/release_notes.md +--- arrayfire-full-3.1.2.orig/docs/pages/release_notes.md 2015-09-25 19:16:18.000000000 -0300 ++++ arrayfire-full-3.1.2/docs/pages/release_notes.md 2015-11-02 13:01:04.186402090 -0300 +@@ -31,7 +31,6 @@ + Installers + ----------- + +-* CUDA backend now depends on CUDA 7.5 toolkit + * OpenCL backend now require OpenCL 1.2 or greater + + Bug Fixes +@@ -111,10 +110,6 @@ + * \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 +@@ -138,11 +133,6 @@ + * 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 +@@ -176,7 +166,7 @@ + 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 -Nur arrayfire-full-3.1.2.orig/docs/pages/using_on_linux.md arrayfire-full-3.1.2/docs/pages/using_on_linux.md +--- arrayfire-full-3.1.2.orig/docs/pages/using_on_linux.md 2015-09-25 19:16:18.000000000 -0300 ++++ arrayfire-full-3.1.2/docs/pages/using_on_linux.md 2015-11-02 16:42:20.209742489 -0300 +@@ -1,32 +1,21 @@ +-Using ArrayFire on Linux {#using_on_linux} ++Using ArrayFire on GNU/Linux {#using_on_linux} + ===== + + +-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 the preferred build system. + + ## Pre-requisites + + Before you get started, make sure you have the necessary pre-requisites. + +-- If you are using CUDA, please make sure you have [CUDA 7](https://developer.nvidia.com/cuda-downloads) installed on your system. +- - [Contact us](support@arrayfire.com) for custom builds (eg. different toolkits) +- + - If you are using OpenCL, please make sure you have one of the following SDKs. + - [AMD OpenCL SDK](http://developer.amd.com/tools-and-sdks/opencl-zone/amd-accelerated-parallel-processing-app-sdk/) + - [Intel OpenCL SDK](https://software.intel.com/en-us/articles/download-the-latest-intel-amt-software-development-kit-sdk) +- - [NVIDIA CUDA](https://developer.nvidia.com/cuda-downloads) + + You will also need the following dependencies to use ArrayFire. + +-#### Fedora, Centos and Redhat +- +-Install EPEL repo (not required for Fedora) +- +-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +-yum install epel-release +-yum update +-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ++#### BLAG Linux and GNU + + Install the common dependencies + +@@ -37,15 +26,11 @@ + + Install glfw (not required for no-gl installers) + +-Fedora: +- + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + yum install glfw + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +-For Centos and Redhat, please follow [these instructions](https://github.com/arrayfire/arrayfire/wiki/GLFW-for-ArrayFire) +- +-#### Debian and Ubuntu ++#### GnewSense and Trisquel + + Install common dependencies + +@@ -60,8 +45,6 @@ + apt-get install libglfw3 + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +-For Debian 7 and Ubuntu 14.04, please follow [these instructions](https://github.com/arrayfire/arrayfire/wiki/GLFW-for-ArrayFire) +- + **Special instructions for Tegra-K1** + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +@@ -70,13 +53,12 @@ + + ## CMake + +-This is the suggested method of using ArrayFire on Linux. ++This is the suggested method of using ArrayFire on GNU/Linux. + ArrayFire ships with support for CMake by default, including a series of + `Find` scripts installed in the `/usr/local/share/ArrayFire/cmake` (or similar) + directory. +-These scripts will automatically find the CUDA, OpenCL, and CPU versions +-of ArrayFire and automatically choose the most powerful installed backend +-(typically CUDA). ++These scripts will automatically find the OpenCL, and CPU versions ++of ArrayFire and automatically choose the most powerful installed backend. + + To use ArrayFire, simply insert the `FIND_PACKAGE` command inside of your + `CMakeLists.txt` file as follows: +@@ -99,14 +81,12 @@ + + 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 + + Therefore, if you wish to target a specific specific backend, switch + `${ArrayFire_LIBRARIES}` to `${ArrayFire_CPU}` `${ArrayFire_OPENCL}` or +-`${ArrayFire_CUDA}` in the `TARGET_LINK_LIBRARIES` command above. ++in the `TARGET_LINK_LIBRARIES` command above. + + Finally, if you have installed ArrayFire to a non-standard location, CMake can still help + you out. When you execute CMake specify the path to the `ArrayFireConfig*` files that +@@ -127,8 +107,8 @@ + instructions. + Then, in your linker line specify the path to ArrayFire using the `-L` option + (typically `-L/usr/lib` or `-L/usr/local/lib` and the specific ArrayFire backend +-you wish to use with the `-l` option (i.e. `-lafcpu`, `-lafopencl` or `-lafcuda` +-for the CPU, OpenCL and CUDA backends repsectively). ++you wish to use with the `-l` option (i.e. `-lafcpu` or `-lafopencl` for the CPU ++and OpenCL backends repsectively). + + Here is a minimial example MakeFile which uses ArrayFire's CPU backend: + |