GPU Training in Bonn

This instructor-led, live training in Bonn (online or onsite) is tailored for beginner to intermediate-level developers who aim to use OpenACC to program heterogeneous devices and capitalize on their parallelism.

By the conclusion of this training, participants will be able to:

• Set up an OpenACC development environment.
• Write and run a basic OpenACC program.
• Annotate code with OpenACC directives and clauses.
• Utilize the OpenACC API and libraries.
• Profile, debug, and optimize OpenACC programs.

This instructor-led, live training in Bonn (online or onsite) is aimed at beginner-level to intermediate-level developers who wish to learn the basics of GPU programming and the main frameworks and tools for developing GPU applications.

• By the end of this training, participants will be able to:
  Understand the difference between CPU and GPU computing and the benefits and challenges of GPU programming.
• Choose the right framework and tool for their GPU application.
• Create a basic GPU program that performs vector addition using one or more of the frameworks and tools.
• Use the respective APIs, languages, and libraries to query device information, allocate and deallocate device memory, copy data between host and device, launch kernels, and synchronize threads.
• Use the respective memory spaces, such as global, local, constant, and private, to optimize data transfers and memory accesses.
• Use the respective execution models, such as work-items, work-groups, threads, blocks, and grids, to control the parallelism.
• Debug and test GPU programs using tools such as CodeXL, CUDA-GDB, CUDA-MEMCHECK, and NVIDIA Nsight.
• Optimize GPU programs using techniques such as coalescing, caching, prefetching, and profiling.

This instructor-led live training, delivered either online or on-site, is designed for developers at the beginner to intermediate level. It focuses on utilizing various frameworks for GPU programming, providing a comprehensive comparison of their features, performance characteristics, and compatibility.

By the conclusion of this program, participants will possess the ability to:

• Establish a robust development environment equipped with the OpenCL SDK, CUDA Toolkit, ROCm Platform, a supporting device (compatible with OpenCL, CUDA, or ROCm), and Visual Studio Code.
• Construct basic GPU applications for vector addition using OpenCL, CUDA, and ROCm, while analyzing the differences in syntax, structure, and execution flow among the frameworks.
• Apply the respective APIs to query device details, manage memory allocation, handle host-to-device data transfers, launch kernels, and synchronize threads.
• Write device-executed kernels and manipulate data using the specific language syntax of each framework.
• Utilize framework-specific built-in functions, variables, and libraries to execute standard tasks efficiently.
• Leverage distinct memory spaces, such as global, local, constant, and private, to optimize data movement and access patterns.
• Manage parallelism by controlling the execution model elements, such as threads, blocks, grids, or work-groups, specific to each framework.
• Perform debugging and testing of GPU applications using tools like CodeXL, CUDA-GDB, CUDA-MEMCHECK, and NVIDIA Nsight.
• Implement performance optimizations through techniques such as coalescing, caching, prefetching, and profiling.

Designed for developers with beginner to intermediate experience, this live instructor-led session is delivered either virtually or on-site. The curriculum focuses on deploying and utilizing ROCm on the Windows platform, empowering participants to effectively program AMD GPUs and harness their parallel processing capabilities.

Upon completion of this training, attendees will possess the skills to:

• Configure a development workspace integrating the ROCm Platform, an AMD GPU, and Visual Studio Code within a Windows environment.
• Develop a foundational ROCm application that executes vector addition on the GPU and retrieves results from device memory.
• Leverage the ROCm API to interrogate device specifications, manage device memory allocation and deallocation, transfer data between host and device, initiate kernel execution, and synchronize threads.
• Compose kernels in HIP that run on the GPU to process and manipulate data.
• Utilize HIP’s built-in functions, variables, and libraries to streamline common tasks and operations.
• Apply ROCm and HIP memory hierarchies—including global, shared, constant, and local spaces—to enhance data transfer efficiency and memory access patterns.
• Manage parallelism by controlling threads, blocks, and grids through ROCm and HIP execution models.
• Diagnose and validate ROCm and HIP applications using specialized tools like the ROCm Debugger and ROCm Profiler.
• Enhance the performance of ROCm and HIP code through strategies such as coalescing, caching, prefetching, and profiling.

This instructor-led, live training in Bonn (online or onsite) is designed for developers ranging from beginner to intermediate levels who wish to program AMD GPUs using ROCm and HIP to exploit their parallelism.

Upon completion of this training, participants will be equipped to:

• Establish a development environment incorporating the ROCm Platform, an AMD GPU, and Visual Studio Code.
• Develop a fundamental ROCm application that executes vector addition on the GPU and retrieves results from GPU memory.
• Leverage the ROCm API to query device specifications, manage memory allocation and deallocation, transfer data between host and device, launch kernels, and synchronize threads.
• Compose kernels in HIP that run on the GPU and manipulate data efficiently.
• Utilize HIP’s built-in functions, variables, and libraries to execute standard tasks and operations.
• Apply ROCm and HIP memory spaces, including global, shared, constant, and local memory, to enhance data transfer and memory access performance.
• Utilize ROCm and HIP execution models to manage threads, blocks, and grids, thereby defining the level of parallelism.
• Debug and test ROCm and HIP applications using tools such as the ROCm Debugger and ROCm Profiler.
• Optimize ROCm and HIP code by employing techniques like coalescing, caching, prefetching, and profiling.

Elevate neural network inference performance on Ascend AI processors through this advanced, instructor-led course in Bonn. Delve into CANN's runtime architecture and utilize the Graph Engine, TIK, and TVM to master profiling, custom operator creation, and the resolution of memory bottlenecks.

This instructor-led live training in Bonn (online or onsite) is designed for developers from beginner to intermediate levels who wish to program NVIDIA GPUs using CUDA to utilize their parallel processing capabilities.

By the end of this training, participants will be able to:

• Set up a development environment featuring the CUDA Toolkit, an NVIDIA GPU, and Visual Studio Code.
• Build a basic CUDA program that performs vector addition on the GPU and retrieves results from GPU memory.
• Utilize the CUDA API to query device details, manage device memory, transfer data between host and device, launch kernels, and synchronize threads.
• Use CUDA C/C++ to write kernels that execute on the GPU and manipulate data.
• Apply CUDA built-in functions, variables, and libraries to handle common tasks and operations.
• Leverage CUDA memory spaces, such as global, shared, constant, and local, to optimize data transfers and memory access.
• Employ the CUDA execution model to control threads, blocks, and grids that define parallelism.
• Debug and test CUDA programs using tools like CUDA-GDB, CUDA-MEMCHECK, and NVIDIA Nsight.
• Enhance CUDA program performance through techniques such as coalescing, caching, prefetching, and profiling.

97% of clients are satisfied. 

This live, instructor-led training in Bonn, delivered either online or on-site, is specifically tailored for beginner-level system administrators and IT professionals seeking to master the installation, configuration, management, and troubleshooting of CUDA environments.

By the end of the session, participants will have the capability to:

• Understand the underlying architecture, components, and full range of CUDA capabilities.
• Install and properly configure CUDA environments.
• Manage and optimize CUDA resources for efficiency.
• Debug and address common CUDA-related issues.

This instructor-led live training in Bonn, offered online or onsite, targets developers from beginner to intermediate levels who intend to use OpenCL for heterogeneous device programming and parallelism exploitation.

By the end of this training, participants will be capable of:

• Setting up a development environment that includes the OpenCL SDK, an OpenCL-supported device, and Visual Studio Code.
• Creating a basic OpenCL program that performs vector addition on the device and retrieves results from device memory.
• Using the OpenCL API to query device information and create contexts, command queues, buffers, kernels, and events.
• Using the OpenCL C language to write kernels that execute on the device and manipulate data.
• Utilizing OpenCL built-in functions, extensions, and libraries to perform common tasks and operations.
• Applying OpenCL host and device memory models to optimize data transfers and memory accesses.
• Controlling work-items, work-groups, and ND-ranges using the OpenCL execution model.
• Debugging and testing OpenCL programs using tools such as CodeXL, Intel VTune, and NVIDIA Nsight.
• Optimizing OpenCL programs using techniques such as vectorization, loop unrolling, local memory, and profiling.

This instructor-led, live training in Bonn (available online or onsite) targets C++ developers seeking to leverage CUDA for application acceleration, high-performance GPU kernel creation, and the use of parallel algorithm libraries in scientific computing, data processing, and machine learning environments.

This live, instructor-led training in Bonn (offered online or onsite) is designed for C/C++ developers aiming to boost the performance of compute-intensive applications using CUDA. The scope includes data processing, scientific simulations, machine learning tasks, and image processing pipelines.

This live, instructor-led training in Bonn—delivered online or on-site—is designed for software developers, data analysts, and technical professionals who intend to utilize TensorFlow 2.x and Keras to build, train, and deploy deep learning models for computer vision, natural language processing, and multimodal applications.

This live, instructor-led training session, conducted in Bonn, provides a comprehensive guide to programming GPUs for parallel computing. It covers the utilization of various platforms, with a specific focus on the CUDA platform, its core features, and the implementation of advanced optimization techniques. The course highlights practical applications across deep learning, analytics, image processing, and engineering solutions.