这个社区有点冷，发个C和C++的查询平台和设备的简单实例代码~

2023-12-08 09:35:48 743 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›
piaopiaolanghua piaopiaolanghua 墨衍会员 · AI 创作全网分发 墨衍智能分发 通过墨衍一键同步至各平台 可同步平台 CSDN微信公众号微博知乎掘金百家号博客园抖音小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 + 加入社区
BitNet.cpp：纯C++实现的1-bit大模型推理引擎 1-bit神经网络是一种将权重与激活值严格限制在{-1, +1}二值空间的极低精度计算范式，其核心原理是将矩阵乘法转化为位运算（如POPCNT）与符号统计，从而绕过传统浮点或整数乘加单元，在硬件层面实现能效跃升。相比INT4量化或FP16推理，1-bit模型显著降低内存带宽需求与功耗，特别适用于嵌入式、边缘设备及离线教学等对资源敏感的场景。BitNet.cpp作为该范式的代表性开源实现，以纯C++构建零Python依赖、内存确定性、指令集深度优化的推理引擎，支持AVX2/NEON加速与裸机部署，使大语言模型 阅读详情
//#include <QCoreApplication>

#include <stdio.h>
#include <stdlib.h>

#include <CL/cl.h>

//static cl_int AllocateAndGetPlatformInfoString(cl_platform_id platformId,
//                                               cl_platform_info param_name,
//                                               char** pStr)
//{
//    cl_int errorCode = CL_SUCCESS;

//    size_t size = 0;
//    char* str = NULL;

//    if (errorCode == CL_SUCCESS)
//    {
//        errorCode = clGetPlatformInfo(platformId, param_name, 0, NULL, &size);
//    }

//    if (errorCode == CL_SUCCESS)
//    {
//        if (size != 0)
//        {
//            str = (char*)malloc(size);
//            if (str == NULL)
//            {
//                errorCode = CL_OUT_OF_HOST_MEMORY;
//            }
//        }
//    }

//    if (errorCode == CL_SUCCESS)
//    {
//        errorCode = clGetPlatformInfo(platformId, param_name, size, str, NULL);
//    }

//    if (errorCode != CL_SUCCESS)
//    {
//        free(str);
//    }
//    else
//    {
//        *pStr = str;
//    }

//    return errorCode;
//}

//static cl_int PrintPlatformInfoSummary(cl_platform_id platformId)
//{
//    cl_int errorCode = CL_SUCCESS;

//    char* platformName = NULL;
//    char* platformVendor = NULL;
//    char* platformVersion = NULL;

//    errorCode |= AllocateAndGetPlatformInfoString(platformId, CL_PLATFORM_NAME,
//                                                  &platformName);
//    errorCode |= AllocateAndGetPlatformInfoString(
//        platformId, CL_PLATFORM_VENDOR, &platformVendor);
//    errorCode |= AllocateAndGetPlatformInfoString(
//        platformId, CL_PLATFORM_VERSION, &platformVersion);

//    printf("\tName:           %s\n", platformName);
//    printf("\tVendor:         %s\n", platformVendor);
//    printf("\tDriver Version: %s\n", platformVersion);

//    free(platformName);
//    free(platformVendor);
//    free(platformVersion);

//    return errorCode;
//}

//static cl_int AllocateAndGetDeviceInfoString(cl_device_id device,
//                                             cl_device_info param_name,
//                                             char** pStr)
//{
//    cl_int errorCode = CL_SUCCESS;

//    size_t size = 0;
//    char* str = NULL;

//    if (errorCode == CL_SUCCESS)
//    {
//        errorCode = clGetDeviceInfo(device, param_name, 0, NULL, &size);
//    }

//    if (errorCode == CL_SUCCESS)
//    {
//        if (size != 0)
//        {
//            str = (char*)malloc(size);
//            if (str == NULL)
//            {
//                errorCode = CL_OUT_OF_HOST_MEMORY;
//            }
//        }
//    }

//    if (errorCode == CL_SUCCESS)
//    {
//        errorCode = clGetDeviceInfo(device, param_name, size, str, NULL);
//    }

//    if (errorCode != CL_SUCCESS)
//    {
//        free(str);
//    }
//    else
//    {
//        *pStr = str;
//    }

//    return errorCode;
//}

//static void PrintDeviceType(const char* label, cl_device_type type)
//{
//    printf("%s%s%s%s%s%s\n", label,
//           (type & CL_DEVICE_TYPE_DEFAULT) ? "DEFAULT " : "",
//           (type & CL_DEVICE_TYPE_CPU) ? "CPU " : "",
//           (type & CL_DEVICE_TYPE_GPU) ? "GPU " : "",
//           (type & CL_DEVICE_TYPE_ACCELERATOR) ? "ACCELERATOR " : "",
//           (type & CL_DEVICE_TYPE_CUSTOM) ? "CUSTOM " : "");
//}

//static cl_int PrintDeviceInfoSummary(cl_device_id* devices, cl_uint numDevices)
//{
//    cl_int errorCode = CL_SUCCESS;

//    cl_device_type deviceType;
//    char* deviceName = NULL;
//    char* deviceVendor = NULL;
//    char* deviceVersion = NULL;
//    char* deviceProfile = NULL;
//    char* driverVersion = NULL;

//    cl_uint i = 0;
//    for (i = 0; i < numDevices; i++)
//    {
//        errorCode |= clGetDeviceInfo(devices[i], CL_DEVICE_TYPE,
//                                     sizeof(deviceType), &deviceType, NULL);
//        errorCode |= AllocateAndGetDeviceInfoString(devices[i], CL_DEVICE_NAME,
//                                                    &deviceName);
//        errorCode |= AllocateAndGetDeviceInfoString(
//            devices[i], CL_DEVICE_VENDOR, &deviceVendor);
//        errorCode |= AllocateAndGetDeviceInfoString(
//            devices[i], CL_DEVICE_VERSION, &deviceVersion);
//        errorCode |= AllocateAndGetDeviceInfoString(
//            devices[i], CL_DEVICE_PROFILE, &deviceProfile);
//        errorCode |= AllocateAndGetDeviceInfoString(
//            devices[i], CL_DRIVER_VERSION, &driverVersion);

//        if (errorCode == CL_SUCCESS)
//        {
//            printf("Device[%u]:\n", i);

//            PrintDeviceType("\tType:           ", deviceType);

//            printf("\tName:           %s\n", deviceName);
//            printf("\tVendor:         %s\n", deviceVendor);
//            printf("\tDevice Version: %s\n", deviceVersion);
//            printf("\tDevice Profile: %s\n", deviceProfile);
//            printf("\tDriver Version: %s\n", driverVersion);
//        }
//        else
//        {
//            fprintf(stderr, "Error getting device info for device %u.\n", i);
//        }

//        free(deviceName);
//        free(deviceVendor);
//        free(deviceVersion);
//        free(deviceProfile);
//        free(driverVersion);
//    }

//    return errorCode;
//}

//int main0(int argc, char** argv)
//{
//    cl_uint numPlatforms = 0;
//    clGetPlatformIDs(0, NULL, &numPlatforms);
//    printf("Enumerated %u platforms.\n\n", numPlatforms);

//    cl_platform_id* platforms =
//        (cl_platform_id*)malloc(numPlatforms * sizeof(cl_platform_id));
//    clGetPlatformIDs(numPlatforms, platforms, NULL);

//    cl_uint i = 0;
//    for (i = 0; i < numPlatforms; i++)
//    {
//        printf("Platform[%u]:\n", i);
//        PrintPlatformInfoSummary(platforms[i]);

//        cl_uint numDevices = 0;
//        clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_ALL, 0, NULL, &numDevices);

//        cl_device_id* devices =
//            (cl_device_id*)malloc(numDevices * sizeof(cl_device_id));
//        clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_ALL, numDevices, devices,
//                       NULL);

//        PrintDeviceInfoSummary(devices, numDevices);
//        printf("\n");

//        free(devices);
//    }

//    free(platforms);

//    printf("Done.\n");

//    return 0;
//}


//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------

#include <iostream>
#include <string>
#include <vector>

#include <CL/opencl.hpp>

static cl_int PrintPlatformInfoSummary(cl::Platform platform)
{
    std::cout << "\tName:           " << platform.getInfo<CL_PLATFORM_NAME>()
              << "\n";
    std::cout << "\tVendor:         " << platform.getInfo<CL_PLATFORM_VENDOR>()
              << "\n";
    std::cout << "\tDriver Version: " << platform.getInfo<CL_PLATFORM_VERSION>()
              << "\n";

    return CL_SUCCESS;
}

static void PrintDeviceType(const std::string& label, cl_device_type type)
{
    std::cout << label << ((type & CL_DEVICE_TYPE_DEFAULT) ? "DEFAULT " : "")
              << ((type & CL_DEVICE_TYPE_CPU) ? "CPU " : "")
              << ((type & CL_DEVICE_TYPE_GPU) ? "GPU " : "")
              << ((type & CL_DEVICE_TYPE_ACCELERATOR) ? "ACCELERATOR " : "")
              << ((type & CL_DEVICE_TYPE_CUSTOM) ? "CUSTOM " : "") << "\n";
}

static cl_int PrintDeviceInfoSummary(const std::vector<cl::Device> devices)
{
    for (size_t i = 0; i < devices.size(); i++)
    {
        std::cout << "Device[" << i << "]:\n";

        cl_device_type deviceType = devices[i].getInfo<CL_DEVICE_TYPE>();
        PrintDeviceType("\tType:           ", deviceType);

        std::cout << "\tName:           "
                  << devices[i].getInfo<CL_DEVICE_NAME>() << "\n";
        std::cout << "\tVendor:         "
                  << devices[i].getInfo<CL_DEVICE_VENDOR>() << "\n";
        std::cout << "\tDevice Version: "
                  << devices[i].getInfo<CL_DEVICE_VERSION>() << "\n";
        std::cout << "\tOCL  C Version: "
                  << devices[i].getInfo<CL_DEVICE_OPENCL_C_VERSION>() << "\n";
        std::cout << "\tDevice Profile: "
                  << devices[i].getInfo<CL_DEVICE_PROFILE>() << "\n";
        std::cout << "\tDriver Version: "
                  << devices[i].getInfo<CL_DRIVER_VERSION>() << "\n";
        std::cout << "\tDevices  Units: "
                  << devices[i].getInfo<CL_DEVICE_MAX_COMPUTE_UNITS>() << "\n";
        std::cout << "\tDevices MaxMem: "
                  << devices[i].getInfo<CL_DEVICE_MAX_MEM_ALLOC_SIZE>()/1024/1024 << "MB\n";
        std::cout << "\tDevices LocMem: "
                  << devices[i].getInfo<CL_DEVICE_LOCAL_MEM_SIZE>()/1024 << "KB\n";

//        std::cout << "\tDevice Extensions: "
//                  << devices[i].getInfo<CL_DEVICE_EXTENSIONS>() << "\n";




    }

    return CL_SUCCESS;
}

int main(int argc, char** argv)
{
    std::vector<cl::Platform> platforms;
    cl::Platform::get(&platforms);
    std::cout << "Enumerated " << platforms.size() << " platforms.\n\n";

    for (size_t i = 0; i < platforms.size(); i++)
    {
        std::cout << "Platform[" << i << "]:\n";
        PrintPlatformInfoSummary(platforms[i]);

        std::vector<cl::Device> devices;
        platforms[i].getDevices(CL_DEVICE_TYPE_ALL, &devices);

        PrintDeviceInfoSummary(devices);
        std::cout << "\n";
    }

    std::cout << "Done.\n";

    return 0;
}

 

Qt pro的配置增加一下两行，配合include和lib
LIBS += -LD:/XXXXXXXX/OpenCL-SDK-v2023.04.17-Win-x64/lib/ -lOpenCL
INCLUDEPATH += D:/XXXXXXXX/OpenCL-SDK-v2023.04.17-Win-x64/include
 
...全文
在Jetson边缘设备部署GPT-OSS与llama.cpp：实现本地大语言模型推理 大语言模型（LLM）的部署正从云端向边缘计算场景延伸，其核心挑战在于如何在资源受限的嵌入式平台上实现高效推理。这涉及到模型压缩、硬件加速和推理优化等关键技术原理。通过量化技术（如GGUF格式）可以大幅减少模型体积，而利用专用推理引擎（如llama.cpp）调用边缘GPU（如NVIDIA Jetson的CUDA核心）则能显著提升计算速度。这种技术组合的价值在于实现了数据的本地化处理，保障了隐私与低延迟，为智能终端、离线助手等应用场景提供了可行方案。具体到实践层面，在Jetson设备上成功部署**GPT-OSS 阅读详情

相关推荐

cpp代码-C++基础

cpp代码-C++基础

weixin_38645379

本地大模型三工具分工：llama.cpp、Ollama、LM Studio选型与协同

本地大模型推理涉及运行时引擎、服务化接口和交互界面三大技术层级。llama.cpp作为轻量级C/C++推理运行时，提供极致硬件控制与跨平台部署能力；Ollama则封装为标准化HTTP API服务，实现模型即服务（MaaS）与主流AI框架（如LangChain4j、Dify）无缝集成；LM Studio面向终端用户，以桌面GUI降低使用门槛，支持模型管理、参数调优与RAG插件。三者并非替代关系，而是分层协作：llama.cpp打底保障性能与可控性，Ollama承上提供工程化接入能力，LM Studio启下支撑

aocaiti5781

devcpp一个好用c和c++的软件

一个很好用的c和c++的软件，适合初学者以及各类学习代码的选手

qq_44132478

linux的ubuntu上如何编译C和C++代码写的动态库，以及调用执行

linux的ubuntu上如何编译C和C++代码写的动态库，以及调用执行

jernymy

33个c++重要知识总结（cpp代码）

c++基础知识复习，包含了33个cpp文件，每个文件包含特定主题的知识回顾，使用特定案例重温某些不常用但是重要的算法或函数的使用方法，含注释。

GodFather47
评论
收藏 已收藏
分享
返回顶部
piaopiaolanghua
piaopiaolanghua
OpenCL和异构编程 607 成员 574 内容
+ 加入社区