JACKET
From Jacket Wiki
Back to Introduction to GPU Computing, Forward to Jacket Installation
Contents |
Introduction
Jacket connects the M language (e.g. common to MATLAB®) to the GPU. With the GPU as a backend computation engine, Jacket brings together the best of three important computational worlds: computational speed, visualization, and the user-friendliness of M programming.
Jacket accomplishes this by automatically wrapping the M language into a GPU compatible form. By simply casting input data to Jacket's GPU data structure, M code can run on the GPU. Jacket preserves the interpretive nature of the M language by providing real-time, transparent access to Jacket's GPU compiler.
Optimizing M-code in MATLAB® for performance has traditionally been done by rewriting functions in C/C++ using the MEX interface. As multi-core and multi-CPU systems have been adopted, MATLAB users have turned to PCT and MDCS for parallel execution while C/C++ users have had to adopt MPI or OpenMP. Even with enhanced parallel tools, parallelization is difficult and time consuming and is completely focused on the CPU, ignoring the benefits of data-parallelism on GPUs. Jacket offers performance and productivity enhancements to augment parallelization efforts or to simply improve performance with existing GPU computational resources.
The Jacket System
The Jacket system consists of the following main parts:
Integration with MATLAB
Once Jacket is installed, it is transparently integrated with the MATLAB's user interface and the user can start working interactively through the MATLAB desktop and command window as well as write M-functions using the MATLAB editor and debugger. All Jacket data is visible in the MATLAB workspace, along with any other MATLAB matrices.
GPU Data Types
Jacket provides GPU counterparts to MATLAB's CPU data types, such as real and complex double, single, uint32, int32, logical, etc. Any variable residing in the host (CPU) memory can be cast to Jacket's GPU data types. Jacket's memory management system allocates and manages memory for these variables on the GPU automatically, behind-the-scenes. Any functions called on GPU data will execute on the GPU automatically without any extra programming. These functions are listed on the Jacket Basics page.
GPU Functions
Jacket provides the largest available set of GPU functions in the world, ranging from functions like SUM, SIN, INTERP2, and complex arithmetic to more sophisticated functions like INV, SVD, BESSELJ, and FFT. The supported set of functions continues to grow with every release of Jacket (see the Jacket Function List).
Runtime
The Jacket runtime is the most advanced GPU runtime in the world, providing automated memory management, compile-on-the-fly, and execution optimizations for Jacket-enable code.
Graphics
Jacket's Graphics Library is the only tool in the world that enables a merger of GPU visualizations with computation. With Jacket a simple graphics command can be added at the end of a simulation loop to visualize data as it is being computed while maintaining performance. Try out GSURF, GIMAGE, GSCATTER3, GVOLUME, and more!
SDK and Compiler
The Jacket SDK makes integration of custom CUDA code into Jacket's runtime very easy. With a few simple SDK functions, your CUDA code can benefit from the optimized Jacket platform.
When Jacket applications have completed the development, test, and optimization stages and are ready for deployment, the Jacket JMC allows users to generate license-free executables for distribution to larger user bases.
Help
Interactive help for any Jacket function is available using Jacket's GHELP function.
Jacket Applications and Benefits
Jacket opens the door for MATLAB and GPU programming to many new problems, including scientific computation, financial modeling, biological modeling, video game development, and many others. Jacket is ideal for:
- Rapid Prototyping – Now you can leverage the rapid prototyping benefits of MATLAB for GPU programming.
- GPU Taste Testing – Are you seriously considering GPU computing for your product development? Jacket enables you to taste test the benefits of the GPU before investing a lot of time and money in expensive developmental programs.
- Eliminating the Port – Are you a company which prototypes in MATLAB and then ports code to C/C++ or some other language? Are you unhappy with the speeds that your prototypes achieve in MATLAB? Now you will find that your MATLAB code runs in real time by leveraging the power of GPUs within the MATLAB environment.
- 3D Visualizations – Do you need to render your results using the latest visualization technologies? Do you spend a lot of time trying to figure out how to simply display your results? With Jacket's Graphics Library, you can now do state-of-the art visualizations in MATLAB, without resorting to time-intensive non-MATLAB approaches to visualization.
GPU computing with Jacket delivers several benefits to end-users:
- Tremendous Speed – Jacket-enabled MATLAB scripts achieve speed improvements of 10X – 50X, and in some cases much greater, over equivalent CPU versions.
- Incredible Visualizations – Jacket's Graphics Library dramatically improves MATLAB visualizations. The idea is simple – let the GPU visualize and compute without moving data back to the CPU. The Graphics Library uses an OpenGL rendering system in real-time. These OpenGL programs run and may be modified entirely within the interpretive MATLAB environment.
- User-Friendliness – Jacket is NOT another GPU language. Rather, Jacket eliminates the need to learn GPU-specific programming languages in order to access the benefits of the GPU. Jacket-enabled MATLAB also inherits all of the user-friendly features commonly associated with MATLAB programming.
- Low Cost HPC Solutions – GPU video cards have become standard in most desktop and laptop computers, eliminating the cost of expensive cluster computing alternatives for high-performance computing (HPC) tasks.
Jacket Product Family
Jacket provides a level of productivity and return on investment far beyond any other development platform on the market. While there are many tools that enable performance improvement, Jacket delivers performance at a whole new level by unleashing the power of GPUs to deliver maximum FLOPS per dollar. Jacket Base runs on a single GPU in a system.
Workstations, SMP servers, and Personal Supercomputers (PSCs) with multiple GPUs can benefit from Jacket MGL that extends the single GPU support of the base Jacket product to as many as eight (8) GPUs in a single machine. Where HPC resources, such as GPU clusters, are already in place, Jacket HPC can harness the power of 8 GPUs or more in a cluster or cloud environment.
Jacket DLA extends the real, single precision linear algebra functionality available in the base Jacket product to include complex and double precision functions.
Jacket SLA extends the base Jacket product to include sparse functionality.
Jacket SDK makes integration of custom CUDA code into Jacket's runtime very easy. With a few simple SDK functions, your CUDA code can benefit from the optimized Jacket platform.
Jacket JMC enables the license-free distribution of Jacket-based compiled executables. JMC works in conjunction with the MATLAB Compiler to produce distributable GPU-accelerated executable programs.
Graphics Library provides powerful 3D visualization capabilities for Jacket applications. This is included with the base Jacket product at no additional cost.
Forward to Jacket Installation