#define CL_TARGET_OPENCL_VERSION 200 #include <CL/cl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> // Helper function to check for and report OpenCL errors void check_error(cl_int err, const char* operation) { if (err != CL_SUCCESS) { fprintf(stderr, "Error during %s: %d\n", operation, err); exit(1); } } int main() { cl_int err; cl_device_id device = NULL; cl_context context = NULL; cl_command_queue queue = NULL; const int DATA_SIZE = 1024; const size_t buffer_size = sizeof(int) * DATA_SIZE; // --- 1. Find an OpenCL 2.0+ Platform with SVM Support --- cl_uint num_platforms; err = clGetPlatformIDs(0, NULL, &num_platforms); check_error(err, "clGetPlatformIDs (count)"); if (num_platforms == 0) { fprintf(stderr, "No OpenCL platforms found.\n"); return 1; } cl_platform_id* platforms = (cl_platform_id*)malloc(num_platforms * sizeof(cl_platform_id)); err = clGetPlatformIDs(num_platforms, platforms, NULL); check_error(err, "clGetPlatformIDs (list)"); for (cl_uint i = 0; i < num_platforms; i++) { cl_uint num_devices; err = clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices); if (err != CL_SUCCESS || num_devices == 0) continue; cl_device_id* devices = (cl_device_id*)malloc(num_devices * sizeof(cl_device_id)); err = clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_ALL, num_devices, devices, NULL); if (err != CL_SUCCESS) { free(devices); continue; } for (cl_uint j = 0; j < num_devices; j++) { char version_string[128]; err = clGetDeviceInfo(devices[j], CL_DEVICE_VERSION, sizeof(version_string), version_string, NULL); if (err != CL_SUCCESS) continue; // Check for "OpenCL 2." or "OpenCL 3." if (strstr(version_string, "OpenCL 2.") || strstr(version_string, "OpenCL 3.")) { cl_device_svm_capabilities svm_caps; err = clGetDeviceInfo(devices[j], CL_DEVICE_SVM_CAPABILITIES, sizeof(svm_caps), &svm_caps, NULL); if (err == CL_SUCCESS && (svm_caps & CL_DEVICE_SVM_COARSE_GRAIN_BUFFER)) { device = devices[j]; char platform_name[128]; clGetPlatformInfo(platforms[i], CL_PLATFORM_NAME, sizeof(platform_name), platform_name, NULL); char device_name[128]; clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(device_name), device_name, NULL); printf("Platform: %s\n", platform_name); printf("Device: %s\n", device_name); printf("Device Version: %s\n", version_string); goto device_found; // Found a good device, exit loops } } } free(devices); } free(platforms); device_found: if (device == NULL) { fprintf(stderr, "Could not find an OpenCL 2.0+ device with coarse-grain SVM support.\n"); return 1; } // --- 2. Create Context and Queue --- context = clCreateContext(NULL, 1, &device, NULL, NULL, &err); check_error(err, "clCreateContext"); queue = clCreateCommandQueueWithProperties(context, device, 0, &err); check_error(err, "clCreateCommandQueueWithProperties"); printf("Created context and command queue.\n"); // --- 3. Allocate Unpinned Host Memory --- // Standard `malloc` memory is unpinned. int* host_src_data = (int*)malloc(buffer_size); if (host_src_data == NULL) { fprintf(stderr, "Failed to allocate host source memory.\n"); return 1; } for (int i = 0; i < DATA_SIZE; i++) { host_src_data[i] = i; } printf("Created and populated unpinned host buffer.\n"); // --- 4. Allocate Coarse-Grain SVM Memory --- // Use read/write flags. The allocation will be coarse-grain // because that's what the device supports. cl_mem_flags flags = CL_MEM_READ_WRITE; // Note: No alignment specified (set to 0) int* svm_mem = (int*)clSVMAlloc(context, flags, buffer_size, 0); if (svm_mem == NULL) { fprintf(stderr, "Failed to allocate SVM memory.\n"); clReleaseCommandQueue(queue); clReleaseContext(context); free(host_src_data); return 1; } printf("Allocated coarse-grain SVM buffer.\n"); // --- 5. Copy Host -> SVM (Non-blocking) --- cl_event h2d_event; // We copy from the unpinned host_src_data to the svm_mem buffer. err = clEnqueueSVMMemcpy(queue, CL_FALSE, svm_mem, host_src_data, buffer_size, 0, NULL, &h2d_event); check_error(err, "clEnqueueSVMMemcpy (Host -> SVM)"); printf("Enqueued non-blocking copy from Host -> SVM.\n"); // --- 6. Copy SVM -> Host (Non-blocking) --- // Allocate a new unpinned host buffer for readback int* host_dst_data = (int*)malloc(buffer_size); if (host_dst_data == NULL) { fprintf(stderr, "Failed to allocate host destination memory.\n"); return 1; } cl_event d2h_event; // Copy from svm_mem to the new host_dst_data buffer // This copy must wait for the first (h2d_event) to complete. err = clEnqueueSVMMemcpy(queue, CL_FALSE, host_dst_data, svm_mem, buffer_size, 1, &h2d_event, &d2h_event); check_error(err, "clEnqueueSVMMemcpy (SVM -> Host)"); printf("Enqueued non-blocking copy from SVM -> Host (waits on H2D).\n"); // --- 7. Verify and Clean Up --- // Explicitly wait for the final copy (SVM -> Host) to complete before reading the data. // Since d2h_event already waits on h2d_event, we only need to wait for d2h_event. err = clWaitForEvents(1, &d2h_event); check_error(err, "clWaitForEvents"); printf("All non-blocking copies have completed.\n"); int mismatches = 0; for (int i = 0; i < DATA_SIZE; i++) { if (host_src_data[i] != host_dst_data[i]) { mismatches++; } } if (mismatches > 0) { printf("\nVERIFICATION FAILED! %d mismatches found.\n", mismatches); } else { printf("\nVERIFICATION PASSED! Data copied successfully.\n"); } // Cleanup printf("Cleaning up resources...\n"); clReleaseEvent(h2d_event); clReleaseEvent(d2h_event); clSVMFree(context, svm_mem); clReleaseCommandQueue(queue); clReleaseContext(context); free(host_src_data); free(host_dst_data); return 0; }