OpenSBLI

"A framework for the automated derivation of finite difference solvers from high-level problem descriptions.

OpenSBLI is a Python-based modelling framework that is capable of expanding a set of differential equations written in Einstein notation, and automatically generating C code that performs the finite difference approximation to obtain a solution. This C code is then targetted with the OPS library towards specific hardware backends, such as MPI/OpenMP for execution on CPUs, and CUDA/OpenCL for execution on GPUs.

The main focus of OpenSBLI is on the solution of the compressible Navier-Stokes equations with application to shock-boundary layer interactions (SBLI). However, in principle, any set of equations that can be written in Einstein notation may be solved.

https://opensbli.github.io/

TAL_SH

Tensor algebra library routines for shared memory systems.  The TAL_SH library provides API for performing basic tensor algebra operations on multicore CPU, NVidia GPU, Intel Xeon Phi, and other accelerators.  Basic tensor algebra operations include tensor contraction, tensor product, tensor addition, tensor transpose, multiplication by a scalar, etc., which operate on locally stored tensors.  The execution of tensor operations on accelerators is asynchronous with respect to the CPU host, if the underlying node is heterogeneous.  Both Fortran and C/C++ API interfaces are provided.  The library has a simplified object-oriented design, although without explicit object-oriented syntax.







https://github.com/DmitryLyakh/TAL_SH

cuTT: A High-Performance Tensor Transpose Library for CUDA Compatible GPUs - https://hgpu.org/?p=17219

http://on-demand.gputechconf.com/gtc/2017/presentation/s7255-antti-pekka-hynninen-cutt-a-high-performance-tensor-transpose-library-for-gpus.pdf

SLACK

"This paper presents the design and implementation of low-level library to compute general sums and products over multi-dimensional arrays (tensors). Using only 3 low-level functions, the API at once generalizes core BLAS1-3 as well as eliminates the need for most tensor transpositions. De- spite their relatively low operation count, we show that these transposition steps can become performance limiting in typical use cases for BLAS on tensors. The execution of the present API achieves peak performance on the same order of magnitude as for vendor-optimized GEMM by utilizing a code generator to output CUDA source code for all computational kernels. The outline for these kernels is a multi-dimensional generalization of the MAGMA BLAS matrix multiplication on GPUs. Separate transpositions steps can be skipped because every kernel allows arbitrary multi- dimensional transpositions of the arguments. The library,including its methodology and programming techniques, are made available in SLACK."

https://github.com/frobnitzem/slack

Efficient Primitives for Standard Tensor Linear Algebra - https://dl.acm.org/citation.cfm?id=2949580

medina

"The global climate model ECHAM/MESSy Atmospheric Chemistry (EMAC) is a modular global model that simulates climate change and air quality scenarios. The application includes different sub-models for the calculation of chemical species concentrations, their interaction with land and sea, and the human interaction. The paper presents a source-to-source parser that enables support for Graphics Processing Units (GPU) by the Kinetic Pre-Processor (KPP) general purpose open-source software tool. The requirements of the host system are also described. The source code of the source-to-source parser is available under the MIT License."

https://github.com/CyICastorc/medina

MEDINA: MECCA Development in Accelerators – KPP Fortran to CUDA source-to-source Preprocessor - https://hgpu.org/?p=17241

Snowflake

"Stencil computations are not well optimized by general-purpose production compilers and the increased use of multicore, manycore, and accelerator-based systems makes the optimization problem even more challenging. In this paper we present Snowflake, a Domain Specific Language (DSL) for stencils that uses a "micro-compiler" approach, i.e., small, focused, domain-specific code generators. The approach is similar to that used in image processing stencils, but Snowflake handles the much more complex stencils that arise in scientific computing, including complex boundary conditions, higher- order operators (larger stencils), higher dimensions, variable coefficients, non-unit-stride iteration spaces, and multiple input or output meshes. Snowflake is embedded in the Python language, allowing it to interoperate with popular scientific tools like SciPy and iPython; it also takes advantage of built-in Python libraries for powerful dependence analysis as part of a just-in-time compiler. We demonstrate the power of the Snowflake language and the micro-compiler approach with a complex scientific benchmark, HPGMG, that exercises the generality of stencil support in Snowflake. By generating OpenMP comparable to, and OpenCL within a factor of 2x of hand-optimized HPGMG, Snowflake demonstrates that a micro-compiler can support diverse processor architectures and is performance-competitive whilst preserving a high-level Python implementation."

https://github.com/ucb-sejits/snowflake

Snowflake: A Lightweight Portable Stencil DSL - https://hgpu.org/?p=17333

Bifrost

"A stream processing framework, created to ease the development of high-throughput processing CPU/GPU pipelines. It is specifically designed for digital signal processing (DSP) applications within radio astronomy. A portable C API is provided, along with C++ and Python wrappers.

The heart of bifrost is a flexible ring buffer implementation that allows different signal processing blocks to be connected to form a pipeline. Each block may be assigned to a CPU core, and the ring buffers are used to transport data to and from blocks. Processing blocks may be run on either the CPU or GPU, and the ring buffer will take care of memory copies between the CPU and GPU spaces.

The purpose of bifrost is to allow rapid development of streaming DSP pipelines; that is, it is designed for stream-like data. A simple example of a data stream is the time series voltage data from a radio telescope’s digitizer card. Unlike file-like data, stream-like data has no well defined start and stop points. One can of course take a series of files, each containing a chunk of a time stream, and treat them as a stream.

https://github.com/ledatelescope/bifrost

Bifrost: a Python/C++ Framework for High-Throughput Stream Processing in Astronomy - https://hgpu.org/?p=17424

Synkhronos

"Synkhronos is a Python package for accelerating computation of Theano functions under data parallelism with multiple GPUs. The aim of this package is to speed up program execution with minimum changes to user code. Variables and graphs are constructed as usual with Theano or extensions such as Lasagne. Synkhronos replicates the user-constructed functions and GPU-memory variables on all devices. The user calls these functions as in a serial program; parallel execution across all GPUs is automated. Synkhronos supports management of Theano shared variables across devices, either by reading/writing individually or through collective communications, such as all-reduce, broadcast, etc."

https://github.com/astooke/Synkhronos