#define CL_TARGET_OPENCL_VERSION 300
#include <CL/cl.h>
#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <streambuf>
// Fungsi helper untuk membaca source code kernel dari file
std::string readKernelSource(const char* filename) {
std::ifstream file(filename);
if (!file.is_open()) {
return "";
}
std::string source((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
file.close();
return source;
}
int main() {
const std::string kernelPath = "/home/haidhi/Documents/learn/opencl/opencl/vector_add.cl";
// ============================================================
// 1. PLATFORM & DEVICE - Hardware Discovery
// ============================================================
// PLATFORM: Representasi dari OpenCL implementation (driver dari vendor seperti NVIDIA, AMD, Intel)
// Satu sistem bisa punya multiple platform (misal: Intel CPU + NVIDIA GPU)
cl_platform_id platform;
// DEVICE: Hardware fisik yang akan menjalankan komputasi (GPU, CPU, FPGA, dll)
cl_device_id device;
cl_int err;
// Ambil platform pertama yang tersedia
err = clGetPlatformIDs(1, &platform, NULL);
if (err != CL_SUCCESS) {
std::cerr << "Error getting platform IDs" << std::endl;
return 1;
}
// Coba cari GPU dulu, kalau gagal pakai CPU
// CL_DEVICE_TYPE_GPU: Cari device tipe GPU
// CL_DEVICE_TYPE_CPU: Fallback ke CPU kalau GPU tidak ada
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL);
if (err != CL_SUCCESS) {
err = clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &device, NULL);
if (err != CL_SUCCESS) {
std::cerr << "Error getting device IDs" << std::endl;
return 1;
}
std::cout << "Using CPU device" << std::endl;
} else {
std::cout << "Using GPU device" << std::endl;
}
// Query informasi device (nama device)
char deviceName[128];
clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(deviceName), deviceName, NULL);
std::cout << "Device: " << deviceName << std::endl;
// ============================================================
// 2. CONTEXT - Execution Environment
// ============================================================
// CONTEXT: Environment yang manage semua OpenCL objects (memory, queues, programs)
// Seperti "workspace" atau "session" untuk operasi OpenCL
// Context menghubungkan host (CPU) dengan device (GPU/CPU)
cl_context context = clCreateContext(nullptr, 1, &device, nullptr, nullptr, nullptr);
// ============================================================
// 3. COMMAND QUEUE - Task Scheduler
// ============================================================
// COMMAND QUEUE: Antrian yang menerima commands untuk dieksekusi di device
// Commands dieksekusi secara asinkron dan bisa out-of-order (tergantung properties)
// Seperti "to-do list" untuk device yang akan diproses secara berurutan
cl_command_queue queue = clCreateCommandQueueWithProperties(
context,
device,
nullptr, // nullptr = default properties (in-order execution)
nullptr
);
// ============================================================
// 4. HOST MEMORY - Data di CPU
// ============================================================
// Data input/output yang ada di memori CPU (RAM)
const int ARRAY_SIZE = 1024;
std::vector<float> a(ARRAY_SIZE, 2.0f); // Array a: semua isi 2.0
std::vector<float> b(ARRAY_SIZE, 3.0f); // Array b: semua isi 3.0
std::vector<float> c(ARRAY_SIZE); // Array c: untuk hasil
// ============================================================
// 5. DEVICE MEMORY - Buffer Objects di GPU/Device
// ============================================================
// BUFFER: Memory object yang ada di device memory (VRAM untuk GPU)
// Data harus di-copy dari host memory ke device memory sebelum diproses
// Buffer A: READ_ONLY, copy data dari host ke device saat dibuat
cl_mem bufA = clCreateBuffer(
context,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, // Flags: read-only + copy data
sizeof(float) * ARRAY_SIZE, // Ukuran buffer
a.data(), // Source data dari host
nullptr
);
// Buffer B: READ_ONLY, copy data dari host ke device
cl_mem bufB = clCreateBuffer(
context,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
sizeof(float) * ARRAY_SIZE,
b.data(),
nullptr
);
// Buffer C: WRITE_ONLY, hanya untuk output (tidak perlu copy data)
cl_mem bufC = clCreateBuffer(
context,
CL_MEM_WRITE_ONLY, // Flags: write-only (untuk hasil)
sizeof(float) * ARRAY_SIZE,
nullptr, // Tidak ada initial data
nullptr
);
// ============================================================
// 6. PROGRAM - Compiled Kernel Code
// ============================================================
// PROGRAM: Container untuk kernel code yang sudah di-compile
// Source code (.cl file) harus dibaca, di-compile, dan di-load ke device
// Baca kernel source code dari file
const std::string kernelSource = readKernelSource(kernelPath.c_str());
const char* sourceCStr = kernelSource.c_str();
size_t sourceSize = kernelSource.length();
cl_int program_err;
// Create program dari source code
cl_program program = clCreateProgramWithSource(context, 1, &sourceCStr, &sourceSize, &program_err);
// Compile program untuk device yang dipilih
// Seperti compile C++ code, tapi untuk GPU/device
clBuildProgram(program, 1, &device, nullptr, nullptr, nullptr);
// ============================================================
// 7. KERNEL - Fungsi yang Dijalankan di Device
// ============================================================
// KERNEL: Function yang akan dieksekusi di device secara parallel
// Satu instance kernel dijalankan untuk setiap work-item (seperti thread)
// Ambil kernel bernama "vector_mul" dari program
cl_kernel kernel = clCreateKernel(program, "vector_mul", nullptr);
// Set arguments untuk kernel (seperti passing parameter ke function)
clSetKernelArg(kernel, 0, sizeof(cl_mem), &bufA); // Arg 0: input buffer A
clSetKernelArg(kernel, 1, sizeof(cl_mem), &bufB); // Arg 1: input buffer B
clSetKernelArg(kernel, 2, sizeof(cl_mem), &bufC); // Arg 2: output buffer C
// ============================================================
// 8. EXECUTION - Jalankan Kernel
// ============================================================
// NDRange: N-Dimensional Range - menentukan berapa banyak work-item yang dijalankan
// Global size: Total jumlah work-items (threads) yang akan dijalankan
size_t globalSize = ARRAY_SIZE; // 1024 work-items = 1 work-item per elemen array
// Enqueue kernel untuk dieksekusi
// 1D execution: 1024 work-items akan dijalankan parallel
// Setiap work-item memproses 1 elemen array
clEnqueueNDRangeKernel(queue, kernel, 1, nullptr, &globalSize, nullptr, 0, nullptr, nullptr);
// ============================================================
// 9. TRANSFER RESULTS - Copy dari Device ke Host
// ============================================================
// Read hasil dari device memory (bufC) ke host memory (c.data())
// CL_TRUE: blocking read (tunggu sampai selesai)
clEnqueueReadBuffer(queue, bufC, CL_TRUE, 0, sizeof(float) * ARRAY_SIZE, c.data(), 0, nullptr, nullptr);
// Print hasil
std::cout << "First 5 results: ";
for (int i = 0; i < 5; i++) {
std::cout << c[i] << " "; // Harusnya: 2.0 * 3.0 = 6.0
}
std::cout << std::endl;
// ============================================================
// 10. CLEANUP - Release semua OpenCL resources
// ============================================================
// Penting untuk release memory dan objects untuk hindari memory leak
clReleaseMemObject(bufA);
clReleaseMemObject(bufB);
clReleaseMemObject(bufC);
clReleaseKernel(kernel);
clReleaseProgram(program);
clReleaseCommandQueue(queue);
clReleaseContext(context);
return 0;
}
