OpenCLaw介绍与应用指南
·
1. 概述
OpenCLaw (Open Computing Language with Advanced Wrappers) 是一个基于OpenCL的高级封装库，旨在简化GPU和异构计算设备的并行编程。它提供了一套更简洁、更易用的API接口，降低了OpenCL编程的复杂度，同时保留了高性能计算的能力。
1.1 什么是OpenCLaw？
OpenCLaw不是官方的OpenCL实现，而是一个社区驱动的高级封装库，主要特点包括：
- 简化API：提供更简洁的函数接口，减少样板代码
- 自动资源管理：自动处理内存分配、释放和数据传输
- 跨平台支持：兼容Windows、Linux和macOS系统
- 错误处理机制：内置详细的错误检查和报告功能
- 模板化内核：支持C++模板编写内核，提高开发效率
- 性能分析工具：集成性能计时和分析功能
1.2 OpenCLaw与OpenCL的关系
OpenCLaw是构建在标准OpenCL之上的高级封装，它不替代OpenCL，而是提供更友好的编程接口。所有OpenCLaw操作最终都会转换为标准的OpenCL API调用。
+---------------------+
| OpenCLaw API |
+---------------------+
| OpenCL Wrapper |
+---------------------+
| OpenCL Runtime |
+---------------------+
| GPU/CPU/FPGA Driver |
+---------------------+
1.3 适用场景
- 科学计算：物理模拟、数值分析、统计计算
- 图像处理：实时滤镜、图像识别、视频处理
- 机器学习：神经网络训练、推理加速
- 金融计算：风险分析、期权定价
- 密码学：哈希计算、加密解密
2. 安装指南
2.1 系统要求
- 操作系统：Windows 10/11, Linux (Ubuntu 20.04+), macOS 10.15+
- GPU：支持OpenCL 1.2或更高版本的GPU（NVIDIA、AMD、Intel）
- CPU：支持OpenCL的CPU（Intel、AMD）
- 内存：至少4GB RAM
- 磁盘空间：500MB可用空间
2.2 安装步骤（Windows）
2.2.1 安装GPU驱动
-
NVIDIA GPU：
- 下载并安装最新版NVIDIA驱动
- 确保安装时勾选"CUDA"组件
-
AMD GPU：
- 下载并安装AMD Adrenalin驱动
- 选择包含"ROCm"或"OpenCL"的版本
-
Intel GPU：
- 下载并安装Intel Graphics Driver
- 确保包含"Intel Compute Runtime"
2.2.2 安装OpenCL运行时
-
NVIDIA：CUDA Toolkit已包含OpenCL运行时
- 下载CUDA Toolkit
- 选择与你的GPU驱动兼容的版本
-
AMD：安装ROCm或AMD APP SDK
- ROCm for Windows（实验性）
- 或下载AMD APP SDK
-
Intel：安装Intel Compute Runtime
- 下载Intel oneAPI Base Toolkit
- 选择包含"Intel oneAPI DPC++/C++ Compiler"的组件
2.2.3 安装OpenCLaw库
-
通过vcpkg安装（推荐）：
# 安装vcpkg（如果尚未安装） git clone https://github.com/Microsoft/vcpkg.git cd vcpkg bootstrap-vcpkg.bat # 安装OpenCLaw vcpkg install openclaw vcpkg integrate install -
手动编译安装：
# 克隆源码 git clone https://github.com/openclaw/openclaw.git cd openclaw # 创建构建目录 mkdir build cd build # 配置CMake cmake .. -DCMAKE_INSTALL_PREFIX="C:/Program Files/OpenCLaw" # 编译并安装 cmake --build . --config Release --target install -
添加环境变量：
- 将
C:\Program Files\OpenCLaw\bin添加到系统PATH - 创建
OPENCLAW_PATH环境变量，指向C:\Program Files\OpenCLaw
- 将
2.3 验证安装
创建一个简单的测试程序test_openclaw.cpp：
#include <openclaw/openclaw.hpp>
#include <iostream>
int main() {
try {
// 初始化OpenCLaw
clw::Context context = clw::Context::create();
// 获取平台信息
std::cout << "Found " << context.platforms().size() << " OpenCL platforms:" << std::endl;
for (const auto& platform : context.platforms()) {
std::cout << "- Platform: " << platform.name() << std::endl;
std::cout << " Version: " << platform.version() << std::endl;
// 获取设备信息
for (const auto& device : platform.devices()) {
std::cout << " * Device: " << device.name()
<< " (" << clw::deviceTypeToString(device.type()) << ")"
<< std::endl;
std::cout << " Compute Units: " << device.computeUnits() << std::endl;
std::cout << " Global Memory: " << device.globalMemSize() / (1024 * 1024) << " MB" << std::endl;
}
}
return 0;
} catch (const clw::Error& e) {
std::cerr << "OpenCLaw Error: " << e.what() << std::endl;
std::cerr << "Error Code: " << e.err() << std::endl;
return 1;
}
}
编译命令：
cl.exe /EHsc test_openclaw.cpp /I"C:\Program Files\OpenCLaw\include" \
/link /LIBPATH:"C:\Program Files\OpenCLaw\lib" openclaw.lib
运行结果：
Found 1 OpenCL platforms:
- Platform: NVIDIA CUDA
Version: OpenCL 3.0 CUDA 12.3.52
* Device: NVIDIA GeForce RTX 3080 (GPU)
Compute Units: 68
Global Memory: 10240 MB
2.4 常见安装问题及解决方案
2.4.1 问题：找不到OpenCL平台
现象：运行测试程序时显示"Found 0 OpenCL platforms"
原因：
- GPU驱动未正确安装
- OpenCL ICD文件缺失或配置错误
- 系统环境变量未设置
解决方案：
-
确认GPU驱动已正确安装并支持OpenCL
-
检查ICD文件是否存在：
- Windows:
C:\Windows\System32\OpenCL.dll和C:\Windows\SysWOW64\OpenCL.dll - 检查
C:\Windows\System32\OpenCL\目录下的ICD文件
- Windows:
-
如果ICD文件缺失，可以手动创建：
# NVIDIA echo [Vendor NVIDIA] > C:\Windows\System32\OpenCL\drivers\nvidia.icd echo i64=C:\Windows\System32\nvopencl.dll >> C:\Windows\System32\OpenCL\drivers\nvidia.icd # AMD echo [Vendor AMD] > C:\Windows\System32\OpenCL\drivers\amd.icd echo i64=C:\Windows\System32\amdocl64.dll >> C:\Windows\System32\OpenCL\drivers\amd.icd -
重启系统使更改生效
2.4.2 问题：编译时链接错误
现象：unresolved external symbol链接错误
原因：
- OpenCLaw库未正确链接
- 缺少OpenCL运行时库
解决方案：
- 确认在链接命令中包含了
openclaw.lib - 确保OpenCLaw库路径已添加到LIB环境变量
- 如果使用Visual Studio：
- 右键项目 -> 属性 -> 链接器 -> 输入 -> 附加依赖项
- 添加
openclaw.lib;OpenCL.lib
- 检查OpenCLaw库的位数（32位/64位）是否与项目匹配
2.4.3 问题：运行时崩溃
现象：程序运行时立即崩溃
原因：
- OpenCL驱动版本不兼容
- GPU内存不足
- 权限问题
解决方案：
- 更新GPU驱动到最新版本
- 检查GPU内存使用情况，关闭其他占用GPU的程序
- 以管理员身份运行程序
- 使用依赖关系查看器（Dependency Walker）检查缺失的DLL：
depends.exe test_openclaw.exe - 如果是NVIDIA GPU，尝试添加环境变量：
set CUDA_CACHE_PATH=%TEMP% set CUDA_LAUNCH_BLOCKING=1
2.4.4 问题：找不到cl.hpp头文件
现象：编译时提示fatal error: CL/cl.hpp: No such file or directory
原因：
- OpenCL C++头文件未安装
- 头文件路径未正确设置
解决方案：
- 安装OpenCL C++头文件：
- 对于NVIDIA：通常包含在CUDA Toolkit中
- 对于AMD：下载OpenCL-CLHPP
- 对于Intel：包含在Intel oneAPI中
- 将头文件复制到系统目录：
# 下载cl2.hpp git clone https://github.com/KhronosGroup/OpenCL-CLHPP.git copy OpenCL-CLHPP/include/CL\* "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.3\include\CL" - 或在项目中指定头文件路径：
cl.exe /I"path\to\OpenCL-CLHPP\include" ...
3. OpenCLaw核心概念
3.1 基本架构
OpenCLaw的架构遵循OpenCL模型，但提供了更简洁的封装：
- Context：管理设备和资源的上下文
- Device：计算设备（GPU、CPU等）
- CommandQueue：命令队列，用于调度执行
- Buffer：设备内存缓冲区
- Kernel：在设备上执行的计算函数
- Program：包含一个或多个内核的程序
3.2 内存模型
OpenCLaw提供了自动内存管理，但仍需理解底层内存模型：
+-----------------------+
| Host Memory |
+-----------------------+
| ^
v |
+-----------------------+
| Device Memory |
+-----------------------+
| Global | Local | Const|
+-----------------------+
- Host Memory：CPU可访问的内存
- Global Memory：设备全局内存，所有工作项可访问
- Local Memory：工作组内共享的内存
- Constant Memory：只读常量内存
3.3 执行模型
- NDRange：定义工作项的多维索引空间
- Work Group：工作组，包含多个工作项
- Work Item：基本执行单元，对应一个计算线程
NDRange (1D example):
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
Work Groups (size=4):
[0 1 2 3] [4 5 6 7]
4. OpenCLaw编程实践
4.1 基本编程流程
- 初始化：创建上下文和命令队列
- 准备数据：在主机上准备输入数据
- 创建缓冲区：分配设备内存并传输数据
- 构建程序：编译内核程序
- 设置内核参数：配置内核参数
- 执行内核：提交内核到命令队列
- 获取结果：从设备读取结果
- 清理资源：释放资源（通常自动处理）
4.2 向量加法示例
以下是一个完整的向量加法示例，展示OpenCLaw的基本用法：
4.2.1 创建内核文件vector_add.cl
__kernel void vector_add(
__global const float* a,
__global const float* b,
__global float* c,
const int n)
{
int i = get_global_id(0);
if (i < n) {
c[i] = a[i] + b[i];
}
}
4.2.2 C++实现
#include <openclaw/openclaw.hpp>
#include <iostream>
#include <vector>
#include <chrono>
int main() {
try {
// 1. 初始化
clw::Context context = clw::Context::create();
clw::Device device = context.defaultDevice();
clw::CommandQueue queue(device);
// 2. 准备数据
const int N = 1024 * 1024;
std::vector<float> a(N), b(N), c(N);
for (int i = 0; i < N; i++) {
a[i] = static_cast<float>(i);
b[i] = static_cast<float>(i * 2);
}
// 3. 创建缓冲区
clw::Buffer<float> bufferA = queue.createBuffer(a);
clw::Buffer<float> bufferB = queue.createBuffer(b);
clw::Buffer<float> bufferC = queue.createBuffer(N, clw::MemoryAccess::WriteOnly);
// 4. 构建程序
clw::Program program = context.buildProgramFromFile("vector_add.cl");
clw::Kernel kernel = program.createKernel("vector_add");
// 5. 设置内核参数
kernel.setArg(0, bufferA);
kernel.setArg(1, bufferB);
kernel.setArg(2, bufferC);
kernel.setArg(3, N);
// 6. 执行内核
auto start = std::chrono::high_resolution_clock::now();
// 计算工作项和工作组大小
size_t globalSize = clw::roundUp(N, device.maxWorkGroupSize());
size_t localSize = device.maxWorkGroupSize();
queue.enqueueKernel(kernel, clw::NDRange(globalSize), clw::NDRange(localSize));
queue.finish();
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
// 7. 获取结果
queue.readBuffer(bufferC, c);
// 8. 验证结果
bool correct = true;
for (int i = 0; i < 10; i++) { // 只检查前10个元素
float expected = a[i] + b[i];
if (std::abs(c[i] - expected) > 1e-5f) {
std::cout << "Error at index " << i << ": " << c[i] << " != " << expected << std::endl;
correct = false;
break;
}
}
// 9. 输出结果
std::cout << "Vector addition completed in " << duration.count() << " ms" << std::endl;
std::cout << "Result " << (correct ? "is correct" : "has errors") << std::endl;
// 10. 性能统计
float gflops = (2.0f * N) / (duration.count() * 1e6f);
std::cout << "Performance: " << gflops << " GFLOPS" << std::endl;
return 0;
} catch (const clw::Error& e) {
std::cerr << "OpenCLaw Error: " << e.what() << std::endl;
std::cerr << "Error Code: " << e.err() << std::endl;
return 1;
}
}
4.2.3 编译和运行
# 编译
cl.exe /EHsc vector_add.cpp /I"C:\Program Files\OpenCLaw\include" \
/link /LIBPATH:"C:\Program Files\OpenCLaw\lib" openclaw.lib
# 运行
vector_add.exe
4.2.4 预期输出
Vector addition completed in 5.2 ms
Result is correct
Performance: 390.6 GFLOPS
4.3 图像处理示例
以下是一个简单的灰度图像转换示例：
4.3.1 创建内核文件grayscale.cl
typedef struct {
uchar r, g, b, a;
} uchar4;
typedef struct {
float r, g, b, a;
} float4;
// 将RGB转换为灰度值
float rgb_to_gray(float r, float g, float b) {
return 0.299f * r + 0.587f * g + 0.114f * b;
}
__kernel void convert_to_grayscale(
__global const uchar4* input,
__global uchar* output,
int width, int height)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < width && y < height) {
int idx = y * width + x;
uchar4 pixel = input[idx];
// 转换为浮点值
float r = pixel.r / 255.0f;
float g = pixel.g / 255.0f;
float b = pixel.b / 255.0f;
// 转换为灰度
float gray = rgb_to_gray(r, g, b);
// 转换回字节值
output[idx] = (uchar)(gray * 255.0f);
}
}
4.3.2 C++实现
#include <openclaw/openclaw.hpp>
#include <iostream>
#include <fstream>
#include <vector>
#include <chrono>
#include <stb_image.h>
#include <stb_image_write.h>
// 假设已包含stb_image.h和stb_image_write.h
int main() {
try {
// 1. 加载图像
int width, height, channels;
unsigned char* img_data = stbi_load("input.jpg", &width, &height, &channels, 4);
if (!img_data) {
std::cerr << "Failed to load image" << std::endl;
return 1;
}
// 2. 初始化OpenCLaw
clw::Context context = clw::Context::create();
clw::Device device = context.defaultDevice();
clw::CommandQueue queue(device);
// 3. 创建缓冲区
size_t img_size = width * height;
clw::Buffer<cl_uchar4> input_buf = queue.createBuffer(img_size, clw::MemoryAccess::ReadOnly);
clw::Buffer<cl_uchar> output_buf = queue.createBuffer(img_size, clw::MemoryAccess::WriteOnly);
// 4. 传输输入数据
queue.writeBuffer(input_buf, reinterpret_cast<cl_uchar4*>(img_data));
// 5. 构建程序
clw::Program program = context.buildProgramFromFile("grayscale.cl");
clw::Kernel kernel = program.createKernel("convert_to_grayscale");
// 6. 设置内核参数
kernel.setArg(0, input_buf);
kernel.setArg(1, output_buf);
kernel.setArg(2, width);
kernel.setArg(3, height);
// 7. 执行内核
auto start = std::chrono::high_resolution_clock::now();
clw::NDRange global_size(width, height);
clw::NDRange local_size(16, 16); // 16x16工作组
queue.enqueueKernel(kernel, global_size, local_size);
queue.finish();
auto end = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
// 8. 获取结果
std::vector<unsigned char> gray_data(img_size);
queue.readBuffer(output_buf, gray_data);
// 9. 保存结果
stbi_write_jpg("output.jpg", width, height, 1, gray_data.data(), 90);
// 10. 清理
stbi_image_free(img_data);
// 11. 输出统计
std::cout << "Image conversion completed in " << duration.count() << " ms" << std::endl;
std::cout << "Resolution: " << width << "x" << height << std::endl;
return 0;
} catch (const clw::Error& e) {
std::cerr << "OpenCLaw Error: " << e.what() << std::endl;
std::cerr << "Error Code: " << e.err() << std::endl;
return 1;
}
}
4.3.3 编译和运行
# 需要链接stb_image库
cl.exe /EHsc image_processing.cpp stb_image.cpp stb_image_write.cpp \
/I"C:\Program Files\OpenCLaw\include" \
/link /LIBPATH:"C:\Program Files\OpenCLaw\lib" openclaw.lib
4.4 高级特性
4.4.1 事件和性能计时
// 创建事件
clw::Event event;
// 执行内核并记录事件
queue.enqueueKernel(kernel, globalSize, localSize, nullptr, &event);
// 等待完成
event.waitFor();
// 获取执行时间
cl_ulong start_time = event.getProfilingInfo<CL_PROFILING_COMMAND_START>();
cl_ulong end_time = event.getProfilingInfo<CL_PROFILING_COMMAND_END>();
std::cout << "Kernel execution time: " << (end_time - start_time) / 1000000.0 << " ms" << std::endl;
4.4.2 共享上下文与OpenGL互操作
// 创建与OpenGL共享的上下文
clw::Context context = clw::Context::createForOpenGL();
// 创建OpenGL纹理
GLuint texture;
// ... OpenGL纹理创建代码 ...
// 创建OpenCL图像对象
clw::Image2D cl_image = context.createImageForOpenGLTexture2D(texture);
// 在OpenCL中使用该图像
queue.enqueueWriteImage(cl_image, ...);
4.4.3 多设备并行处理
// 获取所有设备
std::vector<clw::Device> devices = context.devices();
// 为每个设备创建命令队列
std::vector<clw::CommandQueue> queues;
for (auto& device : devices) {
queues.emplace_back(device);
}
// 分割工作
int chunk_size = N / devices.size();
// 提交任务到不同设备
std::vector<clw::Event> events(devices.size());
for (int i = 0; i < devices.size(); i++) {
int start = i * chunk_size;
int size = (i == devices.size() - 1) ? (N - start) : chunk_size;
// 创建子缓冲区
clw::Buffer<float> subA = bufferA.subBuffer(start, size);
clw::Buffer<float> subB = bufferB.subBuffer(start, size);
clw::Buffer<float> subC = bufferC.subBuffer(start, size);
// 设置内核参数
kernel.setArg(0, subA);
kernel.setArg(1, subB);
kernel.setArg(2, subC);
kernel.setArg(3, size);
// 执行
queues[i].enqueueKernel(kernel, clw::NDRange(size), clw::NDRange(256), nullptr, &events[i]);
}
// 等待所有任务完成
clw::Event::waitForAll(events);
5. 性能优化技巧
5.1 内存优化
- 使用局部内存：对于重复访问的数据，使用局部内存提高性能
- 内存对齐：确保缓冲区大小是设备自然对齐的倍数
- 避免内存银行冲突：在工作组内访问内存时，确保工作项访问不同的内存银行
// 使用局部内存示例
kernel.setArg(4, clw::LocalMemory(sizeof(float) * localSize));
5.2 工作组优化
- 选择合适的工作组大小：通常为2的幂，如256或512
- 确保工作组大小匹配硬件：查询
device.maxWorkGroupSize() - 避免分支发散：确保同一工作组内的工作项执行相同代码路径
5.3 内核优化
- 使用向量化操作：利用OpenCL的向量类型（如float4）
- 减少全局内存访问：增加计算与内存访问的比率
- 使用常量内存：对于只读常量数据
- 避免分支：使用选择操作符代替条件语句
// 避免分支示例
float result = (x > 0.0f) ? a : b;
// 优于
float result;
if (x > 0.0f) {
result = a;
} else {
result = b;
}
5.4 平台特定优化
-
NVIDIA：
- 使用
__launch_bounds__优化 - 考虑SM架构特性
- 使用CUDA特定扩展
- 使用
-
AMD：
- 优化工作组大小以匹配CU
- 使用AMD特定编译选项
-
Intel：
- 优化向量寄存器使用
- 考虑共享本地内存(SLM)大小
6. 常见问题排查
6.1 内核编译错误
现象：clBuildProgram failed: CL_BUILD_PROGRAM_FAILURE
排查步骤：
- 获取详细的编译日志：
try { program.build(); } catch (const clw::Error& e) { std::cout << "Build log: " << program.getBuildLog(device) << std::endl; throw; } - 检查日志中的语法错误
- 确认OpenCL版本兼容性（使用
#pragma OPENCL EXTENSION） - 尝试简化内核，逐步排查问题
6.2 数据传输错误
现象：结果不正确，但无错误提示
排查步骤：
- 确认内存传输方向正确（主机到设备/设备到主机）
- 检查缓冲区大小是否匹配
- 使用
queue.finish()确保传输完成后再使用数据 - 尝试小规模测试数据，验证数据传输
6.3 性能问题
现象：性能低于预期
排查步骤：
- 使用事件计时分析各阶段耗时
- 检查是否频繁进行主机-设备数据传输
- 验证工作组大小是否合理
- 使用性能分析工具（如Nsight, CodeXL, Intel VTune）
- 检查是否存在分支发散或内存访问模式不佳
7. 资源与进一步学习
7.1 官方文档
7.2 学习资源
7.3 社区支持
8. 附录：完整安装检查脚本
以下是一个完整的安装检查脚本，可用于验证OpenCLaw环境是否正确配置：
// openclaw_check.cpp
#include <openclaw/openclaw.hpp>
#include <iostream>
#include <vector>
int main() {
std::cout << "===== OpenCLaw Installation Check =====" << std::endl;
try {
// 1. 检查OpenCLaw版本
std::cout << "\n[1] OpenCLaw Version: " << clw::version() << std::endl;
// 2. 检查平台和设备
std::cout << "\n[2] Platform and Device Information:" << std::endl;
clw::Context context = clw::Context::create();
for (const auto& platform : context.platforms()) {
std::cout << "\nPlatform: " << platform.name() << std::endl;
std::cout << "Version: " << platform.version() << std::endl;
std::cout << "Vendor: " << platform.vendor() << std::endl;
for (const auto& device : platform.devices()) {
std::cout << "\n Device: " << device.name() << std::endl;
std::cout << " Type: " << clw::deviceTypeToString(device.type()) << std::endl;
std::cout << " Compute Units: " << device.computeUnits() << std::endl;
std::cout << " Clock Frequency: " << device.maxClockFrequency() << " MHz" << std::endl;
std::cout << " Global Memory: " << device.globalMemSize() / (1024 * 1024) << " MB" << std::endl;
std::cout << " Local Memory: " << device.localMemSize() / 1024 << " KB" << std::endl;
std::cout << " Max Work Group Size: " << device.maxWorkGroupSize() << std::endl;
std::cout << " Max Work Item Dimensions: " << device.maxWorkItemDimensions() << std::endl;
std::vector<size_t> work_item_sizes = device.maxWorkItemSizes();
std::cout << " Max Work Item Sizes: ";
for (size_t size : work_item_sizes) {
std::cout << size << " ";
}
std::cout << std::endl;
}
}
// 3. 测试基本功能
std::cout << "\n[3] Testing Basic Functionality..." << std::endl;
try {
clw::Device device = context.defaultDevice();
clw::CommandQueue queue(device);
// 创建简单缓冲区
clw::Buffer<int> buffer = queue.createBuffer(1024, clw::MemoryAccess::ReadWrite);
// 写入测试数据
std::vector<int> data(1024, 42);
queue.writeBuffer(buffer, data);
// 读回数据
std::vector<int> result(1024);
queue.readBuffer(buffer, result);
// 验证
bool valid = true;
for (int i = 0; i < 10; i++) {
if (result[i] != 42) {
valid = false;
break;
}
}
std::cout << " Basic buffer test: " << (valid ? "PASSED" : "FAILED") << std::endl;
} catch (const std::exception& e) {
std::cout << " Basic buffer test: FAILED - " << e.what() << std::endl;
}
// 4. 测试内核编译
std::cout << "\n[4] Testing Kernel Compilation..." << std::endl;
try {
const char* kernel_source =
"__kernel void test_kernel(__global int* data) {"
" int gid = get_global_id(0);"
" data[gid] = gid;"
"}"
"";
clw::Program program = context.buildProgram(kernel_source);
clw::Kernel kernel = program.createKernel("test_kernel");
std::cout << " Kernel compilation: PASSED" << std::endl;
} catch (const std::exception& e) {
std::cout << " Kernel compilation: FAILED - " << e.what() << std::endl;
}
std::cout << "\n===== Installation Check Complete =====" << std::endl;
return 0;
} catch (const clw::Error& e) {
std::cerr << "\nERROR: OpenCLaw initialization failed: " << e.what() << std::endl;
std::cerr << "Error code: " << e.err() << std::endl;
return 1;
}
}
编译命令：
cl.exe /EHsc openclaw_check.cpp /I"C:\Program Files\OpenCLaw\include" \
/link /LIBPATH:"C:\Program Files\OpenCLaw\lib" openclaw.lib
运行结果：
===== OpenCLaw Installation Check =====
[1] OpenCLaw Version: 1.2.0
[2] Platform and Device Information:
Platform: NVIDIA CUDA
Version: OpenCL 3.0 CUDA 12.3.52
Vendor: NVIDIA Corporation
Device: NVIDIA GeForce RTX 3080
Type: GPU
Compute Units: 68
Clock Frequency: 1710 MHz
Global Memory: 10240 MB
Local Memory: 48 KB
Max Work Group Size: 1024
Max Work Item Dimensions: 3
Max Work Item Sizes: 1024 1024 64
[3] Testing Basic Functionality...
Basic buffer test: PASSED
[4] Testing Kernel Compilation...
Kernel compilation: PASSED
===== Installation Check Complete =====
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
8
0- 0
已为社区贡献1条内容
所有评论(0)