CUDArray

"CUDArray is a CUDA-accelerated subset of the NumPy library. The goal of CUDArray is to combine the easy of development from the NumPy with the computational power of Nvidia GPUs in a lightweight and extensible framework.

The goal of CUDArray is to combine the ease of development from NumPy with the computational power of Nvidia GPUs in a lightweight and extensible framework. Since the motivation behind CUDArray is to facilitate neural network programming, CUDArray extends NumPy with a neural network submodule. This module has both a CPU and a GPU back-end to allow for experiments without requiring a GPU."

https://github.com/andersbll/cudarray

CUDArray: CUDA-based NumPy - http://hgpu.org/?p=13077

PENCIL

"PENCIL is rigorously-defined subset of GNU C99-enriched with additional language constructs-that enables compilers to exploit parallelism and produce highly optimized code when targeting accelerators. PENCIL aims to serve both as a portable implementation language for libraries, and as a target language for DSL compilers. We implemented a PENCIL-to-OpenCL backend using a state-of-the-art polyhedral compiler. The polyhedral compiler, extended to handle data-dependent control flow and non-affine array accesses, generates optimized OpenCL code. To demonstrate the potential and performance portability of PENCIL and the PENCIL-to-OpenCL compiler, we consider a number of image processing kernels, a set of benchmarks from the Rodinia and SHOC suites, and DSL embedding scenarios for linear algebra (BLAS) and signal processing radar applications (SpearDE), and present experimental results for four GPU platforms: AMD Radeon HD 5670 and R9 285, NVIDIA GTX 470, and ARM Mali-T604."

https://github.com/Meinersbur/pencilcc

PENCIL: A Platform-Neutral Compute Intermediate Language for Accelerator Programming - http://hgpu.org/?p=14578

Velociraptor

"Velociraptor is a compiler toolkit designed for array-based languages that is not tied to a single source language. You can use it to build compilers and other tools for array-based languages. Velociraptor takes as input a high-level IR called Velociraptor IR (VRIR for short) which is described below. Velociraptor provides multiple components that can be used to build compilers. The first component libVRIR is an analysis and transformation infrastructure that can be used by both static and dynamic tools. The second component, VRdino, is a dynamic compiler that generates LLVM for CPUs, and OpenCL for GPUs from VRIR.

VRIR is a typed, AST based IR used by Velociraptor. VRIR is designed to be easy to generate from array-based languages. It has built-in operators for many high-level array operations (like matrix multiplication), flexible array indexing schemes, and support for various array layouts. VRIR also includes high-level constructs for parallelism and GPU acceleration. VRIR has a textual representation inspired from Lisp S-expressions.

VRdino is the dynamic backend for Velociraptor. It generates LLVM for CPUs and OpenCL for GPUs, making it portable across many different systems. It performs some interesting optimizations, such as runtime code specialization of regions identified using region detection analysis. VRdino is accompanied by its intelligent runtime system, that is designed for maximizing throughput in hybrid systems by doing operations in parallel and by minimizing redundant data transfers. VRdino depends upon libVRIR, LLVM, OpenCL, BLAS and RaijinCL."

http://www.sable.mcgill.ca/mclab/projects/velociraptor/

A Toolkit for Building Dynamic Compilers for Array-Based Languages Targeting CPUs and GPUs - http://hgpu.org/?p=14628

MAGMA

"Matrix Algebra on GPU and Multicore Architectures (MAGMA) is a collection of next generation linear algebra (LA) libraries for heterogeneous architectures. The MAGMA package supports interfaces for current LA packages and standards, e.g., LAPACK and BLAS, to allow computational scientists to easily port any LA-reliant software components to heterogeneous architectures. MAGMA allows applications to fully exploit the power of current heterogeneous systems of multi/many-core CPUs and multi-GPUs/coprocessors to deliver the fastest possible time to accurate solution within given energy constraints.

MAGMA 1.6 features top performance and high accuracy LAPACK compliant routines for multicore CPUs enhanced with NVIDIA GPUs and includes more than 400 routines, covering one-sided dense matrix factorizations and solvers, two-sided factorizations and eigen/singular-value problem solvers, as well as a subset of highly optimized BLAS for GPUs. In 2014, the MAGMA Sparse and MAGMA Batched packages were added with the MAGMA 1.6 release, providing support for sparse iterative and batched linear algebra on a set of small matrices in parallel, respectively. MAGMA provides multiple precision arithmetic support (S/D/C/Z, including mixed-precision). Most of the algorithms are hybrid, using both multicore CPUs and GPUs, but starting with the 1.6 release, GPU-specific algorithms were added. MAGMA also supports AMD GPUs (clMAGMA 1.3) and Intel Xeon Phi coprocessors (MAGMA MIC 1.3)."

http://icl.eecs.utk.edu/magma/

MAGMA Embedded: Towards a Dense Linear Algebra Library for Energy Efficient Extreme Computing - http://icl.eecs.utk.edu/magma/

Parallel Programming Models for Dense Linear Algebra on Heterogeneous Systems - http://superfri.org/superfri/article/view/90

Investigating Half Precision Arithmetic to Accelerate Dense Linear System Solvers - https://hgpu.org/?p=17870

MetaFork

"MetaFork is a compilation framework for concurrency platforms targeting hardware acceleration technologies. As of today, it consists of a multithreaded language, also called MetaFork, and software tools for performing automatic program translations between CilkPlus, OpenMP and MetaFork."

http://www.metafork.org/

MetaFork: A Compilation Framework for Concurrency Models Targeting Hardware Accelerators and Its Application to the Generation of Parametric CUDA Kernels - http://hgpu.org/?p=14708

BLASX

"A highly optimized multi-GPU level-3 BLAS. We adopt the concepts of algorithms-by-tiles treating a matrix tile as the basic data unit and operations on tiles as the basic task. Tasks are guided with a dynamic asynchronous runtime, which is cache and locality aware. The communication cost under BLASX becomes trivial as it perfectly overlaps communication and computation across multiple streams during asynchronous task progression. It also takes the current tile cache scheme one step further by proposing an innovative 2-level hierarchical tile cache, taking advantage of inter-GPU P2P communication. As a result, linear speedup is observable with BLASX under multi-GPU configurations; and the extensive benchmarks demonstrate that BLASX consistently outperforms the related leading industrial and academic projects such as cuBLAS-XT, SuperMatrix, MAGMA and PaRSEC."

https://github.com/linnanwang/BLASX

BLASX: A High Performance Level-3 BLAS Library for Heterogeneous Multi-GPU Computing - http://hgpu.org/?p=14743

Devito

"Devito is a new tool for performing optimised Finite Difference (FD) computation from high-level symbolic problem definitions. Devito performs automated code generation and Just-In-time (JIT) compilation based on symbolic equations defined in SymPy to create and execute highly optimised Finite Difference kernels on multiple computer platforms."

https://github.com/opesci/devito

Devito: automated fast finite difference computation - http://arxiv.org/abs/1608.08658