Introduction to Generic Accelerated Computing with Libra SDK

转自：http://gpuscience.com/news/introduction-to-generic-accelerated-computing-with-libra-sdk/

Introduction to Generic Accelerated Computing with Libra SDK

Editor |  21 November, 2011

• digg
• 6

   
• 38
  inShare
• Share

A short presentation of GPU Systems and introduction to Libra Compute API – Technology Platform and Ecosystem with a technical hands-on “Hello World” tutorial from Libra SDK is presented.

Libra SDK is a highly sophisticated runtime including API, sample programs and documentation for massively accelerating software computations. This introduction tutorial will provide an overview and usage examples of the powerful Libra API & math libraries executing on x86/x64, OpenCL, OpenGL and CUDA technology. Libra API enables generic and portable CPU/GPU computing within software development without the need to create multiple, specific and optimized code paths to support x86, OpenCL, OpenGL or CUDA devices.”

Key Libra Facts

• Unleash the Teraflop performance of CPUs and GPUs and future compute accelerators using a single standard programming API to access compute resources.
• Libra API enable heterogeneous computing access through high-level programming languages, C/C++ and matlab.
• Develop code once, deploy on numerous CPU and GPU devices to execute on a broad range of chip manufacturers.
• Enable more application performance with less code compared to hardware specific low level APIs, easier to maintain applications & algorithms and faster time to product release – no need to learn new tools or programming languages.

Libra SDK Tutorial 1 :

Libra API to access the power of CUDA, OpenCL/OpenGL and X86/X64 all at once -  enabling a powerful CPU/GPU heterogeneous computing platform within a standard C/C++ software programming environment”. Below is a simple “Hello World” Libra C++ example application:

Update: We had few complaints, that syntax brakes down with certain browsers. Please download a source code as a separate file.

#include <stdio.h>
#include <iostream>
#include <math.h>     // Standard math on x86/x64
#include <Libra.h>    // Standard math on CUDA, OpenCL, OpenGL, x86/x64(<a title="multi-core" href="http://gpuscience.com/tag/multi-core/">multi-core</a>)

int main( int argc, char ** argv)
{
      // Declare some local variables.
        const int N = 1024;
        long long flopCount;
        double startTime, time , gflops;

      // Declare some more local variables
      // A gVar represents a vector, matrix or scalar
      // with elements of float, double, int or bool
        gVar A, B, C;

        //First we initialize Libra by calling libra_Init().
        if (libra_Init(argc, argv) != 0)
            return 1;

      // Then we set some initial compute states -
      // Set compute backend to CUDA_, OPENCL_, OPENGL_ or CPU_BACKEND.
        libra_SetCurrentBackend(CUDA_BACKEND);

      // Set current compute precision to 32bit float
        libra_SetDefaultDataType(GFLOAT32);

      // Create two N by N matrices and initialize all elements to 1.
      A = ones(N, N);
      B = A;

      // Driver warm-ups for accurate timings
      C = A * B * 1.23f + 3.15f;C = A * B * 1.23f + 3.15f;

      // We then perform dense matrix multiplication (SGEMM) and time it.
      // For a DGEMM version, set compute precision to GFLOAT64.
      startTime = libra_GetTime();

      // Perform matrix multiplication, then multiply and bias all elements.
      C = A * B * 1.23f + 3.15f;

        time = libra_GetTime() - startTime;
        printf ( "Total time : %g%s" , time *1000, " milliseconds " );

        // Compute a performance measurement. Gigaflop / s.
        flopCount = (2*N-1)*N*( long long )N;
        gflops = flopCount / time / 1e9;
        printf ( "%g%s" , gflops, " GFlop/s. n" );

      //After printing measurements our program ends and calls libra_Shutdown()           //to cleanup system resources.
        libra_Shutdown();

        return 0;
}

Stay tuned for more examples soon.

About GPU Systems: GPU Systems is a software technology company focusing on enabling the next generation of compute technologies & APIs using current and future hardware architectures. For more information, visit http://www.gpusystems.com

Libra SDK examples: http://www.gpusystems.com/code_examples.aspx

Download Libra SDK: http://www.gpusystems.com/download.aspx

written by Marco Hjerpe for GPU Science
[email protected]
www.gpusystems.com

Tags: CUDA, featured, heterogeneous computing, library, OpenCL, tutorial

Category: Code Examples, Computer Science, News, Training & Events

Related posts:

1. Optimizing Linpack Benchmark on GPU-Accelerated Petascale Supercomputer
2. A generic library for structured real-time computations
3. IBM Files Patent For GPU-Accelerated Databases
4. Introduction to CUDA Programming
5. CUDA by Example: An Introduction to General-Purpose GPU Programming