Scribd
Upload
8 views12 pages

04 CPP Concepts

Uploaded by

cristian.v.achim
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
8 views12 pages

04 CPP Concepts

Uploaded by

cristian.v.achim
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 12

C++ Refresher

High-Level GPU Programming


2024-02
CSC Training
C++ Refresher (for those familiar with C)
Anatomy of a SYCL code

#include <sycl/sycl.hpp>
using namespace sycl;

template <typename T>


void axpy(queue &q, const T &a, const std::vector<T> &x, std::vector<T> &y) {
range<1> N{x.size()};
buffer x_buf(x.data(), N);
buffer y_buf(y.data(), N);

q.submit([&](handler &h) {
auto x = x_buf.template get_access<access::mode::read>(h); // accessor x(x_buf, h, read_only);
auto y = y_buf.template get_access<access::mode::read_write>(h); // accessor y(y_buf, h, read_write);

h.parallel_for(N, [=](id<1> i) {
y[i] += a * x[i];
});
});
q.wait_and_throw();
}

SYCL and Kokkos are modern C++ with classes, templates, lambdas, …
Namespaces

Namespace is a way of organizing variables, functions, classes, etc.


// Fully qualified name
sycl::queue q{};

// Using names from the namespace


using namespace sycl;
queue q{};
Templates

Templates allow writing generic functions and classes


template <typename T>
T max(T a, T b) {
return (a > b) ? a : b;
}

int a = 1, b = 2;
int c = max(a, b);

double x = 3.4, y = 5.6;


double z = max(x, y);
Pointers and references

Pointer: Memory address of another variable (as in C)


void foo1(int *a) { *a = 42; }

int *x = new int[1];


foo1(x);
std::cout << *x << std::endl;
delete[] x;

Reference: Alias of another variable


void foo2(int &a) { a = 42; }

int y;
int &z = y;
foo2(z);
std::cout << y << std::endl;
auto

auto can be used in variable declaration if the compiler can deduce the
type during compilation
auto a = 5;

auto queue_event = queue.submit([&](handler& h) {...});


Lambdas

Anonymous function objects


Syntax: [ captures ] (parameters) -> return-type { body }
int a = 1;
auto add = [=](int b) -> int { return a + b; };
int sum = add(2); // 3

auto set = [&](int b) { a = b; };


set(5); // a = 5

sum = add(2); // 3 or 7?
Classes

Composite data type grouping variables and functions


template <typename T> Particle<double> p{1.2, 3.4};
class Particle { p.print();
private: p.move(5.6, 7.8);
T x, y; p.print();

public:
Particle(T x, T y) {
this->x = x;
this->y = y;
}

void move(T dx, T dy) {


x += dx;
y += dy;
}

void print() {
std::cout << x << " " << y << std::endl;
}
};
Functors

Objects that behave as functions


class Adder {
private:
const int constant;
public:
Adder(int c) : constant{c} {}
int operator()(int a) { return constant + a; }
};

Adder add{5};
int sum = add(2);
std::cout << "The sum is: " << sum << std::endl;
Error Handling

Errors are handled via C++ exceptions


int main() {
int x, y;
std::cout << "Enter two numbers: ";
std::cin >> x >> y;

try {
if (y == 0) throw "Division by zero error";
std::cout << "x / y = " << x / y << std::endl;
} catch (const char* msg) {
std::cerr << "Error: " << msg << std::endl;
}
return 0;
}
Summary

SYCL and Kokkos are modern C++ aiming towards generic parallel
programming
Classes, templates, lambdas, …
Reusable, expressive, and efficient code

You might also like