Changeset 3821 in CLRX


Ignore:
Timestamp:
Feb 18, 2018, 1:04:36 PM (18 months ago)
Author:
matszpk
Message:

CLRadeonExtender: Add support for multiple OpenCL platforms to CLHelper and samples.

Location:
CLRadeonExtender/trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/CLRX/clhelper/CLHelper.h

    r3806 r3821  
    2525
    2626#include <CLRX/Config.h>
     27#include <exception>
    2728#include <vector>
    2829#include <utility>
     
    6667/// choose suitable OpenCL platform for CLRX assembler programs
    6768extern cl_platform_id chooseCLPlatformForCLRX();
     69
     70/// choose suitable OpenCL many platforms for CLRX assembler programs
     71extern std::vector<cl_platform_id> chooseCLPlatformsForCLRX();
    6872
    6973enum : Flags
  • CLRadeonExtender/trunk/clhelper/CLHelper.cpp

    r3807 r3821  
    7474/* main routines */
    7575
    76 cl_platform_id CLRX::chooseCLPlatformForCLRX()
     76static std::vector<cl_platform_id> chooseCLPlatformsForCLRXInt(bool single = true)
    7777{
    7878    cl_int error = CL_SUCCESS;
     
    8787        throw CLError(error, "clGetPlatformIDs");
    8888   
    89     cl_platform_id choosenPlatform = nullptr;
     89    std::vector<cl_platform_id> choosenPlatforms;
    9090    /// find platform with AMD or GalliumCompute devices
    9191    for (cl_uint i = 0; i < platformsNum; i++)
     
    108108            ::strcmp(splatformName, "Clover")==0)
    109109        {
    110             choosenPlatform = platforms[i];
    111             break;
    112         }
    113     }
    114    
    115     if (choosenPlatform==nullptr)
     110            choosenPlatforms.push_back(platforms[i]);
     111            if (single)
     112                break;
     113        }
     114    }
     115   
     116    if (choosenPlatforms.empty())
    116117        throw Exception("PlatformNotFound");
    117118   
    118     return choosenPlatform;
     119    return choosenPlatforms;
     120}
     121
     122cl_platform_id CLRX::chooseCLPlatformForCLRX()
     123{
     124    return chooseCLPlatformsForCLRXInt()[0];
     125}
     126
     127std::vector<cl_platform_id> CLRX::chooseCLPlatformsForCLRX()
     128{
     129    return chooseCLPlatformsForCLRXInt(false);
    119130}
    120131
  • CLRadeonExtender/trunk/samples/CLUtils.cpp

    r3814 r3821  
    5252   
    5353    cl_int error = CL_SUCCESS;
    54     cl_platform_id choosenPlatform = chooseCLPlatformForCLRX();
     54    const std::vector<cl_platform_id> choosenPlatforms = chooseCLPlatformsForCLRX();
    5555   
    5656    if (argc >= 2 && ::strcmp(argv[1], "-L")==0)
    5757    {
    58         // list devices, before it get GPU devices
    59         cl_uint devicesNum;
    60         std::unique_ptr<cl_device_id[]> devices;
    61         error = clGetDeviceIDs(choosenPlatform, CL_DEVICE_TYPE_GPU, 0,
    62                                nullptr, &devicesNum);
    63         if (error != CL_SUCCESS)
    64             throw CLError(error, "clGetDeviceIDs");
    65        
    66         devices.reset(new cl_device_id[devicesNum]);
    67         error = clGetDeviceIDs(choosenPlatform, CL_DEVICE_TYPE_GPU,
    68                         devicesNum, devices.get(), nullptr);
    69         if (error != CL_SUCCESS)
    70             throw CLError(error, "clGetDeviceIDs");
    71        
    72         for (cl_uint i = 0; i < devicesNum; i++)
     58        cxuint devPlatformStart = 0;
     59        for (cl_platform_id choosenPlatform: choosenPlatforms)
    7360        {
    74             cl_device_id device = devices[i];
    75             // get device and print that
    76             size_t deviceNameSize;
    77             std::unique_ptr<char[]> deviceName;
    78             error = clGetDeviceInfo(device, CL_DEVICE_NAME, 0, nullptr, &deviceNameSize);
    79             if (error != CL_SUCCESS)
    80                 throw CLError(error, "clGetDeviceInfoName");
    81             deviceName.reset(new char[deviceNameSize]);
    82             error = clGetDeviceInfo(device, CL_DEVICE_NAME, deviceNameSize,
    83                                      deviceName.get(), nullptr);
    84             if (error != CL_SUCCESS)
    85                 throw CLError(error, "clGetDeviceInfoName");
    86             std::cout << "Device: " << i << " - " << deviceName.get() << "\n";
     61            size_t platformNameSize;
     62            std::unique_ptr<char[]> platformName;
     63            error = clGetPlatformInfo(choosenPlatform, CL_PLATFORM_NAME, 0, nullptr,
     64                            &platformNameSize);
     65            if (error != CL_SUCCESS)
     66                throw CLError(error, "clGetPlatformInfoName");
     67            platformName.reset(new char[platformNameSize]);
     68            error = clGetPlatformInfo(choosenPlatform, CL_PLATFORM_NAME, platformNameSize,
     69                                    platformName.get(), nullptr);
     70            if (error != CL_SUCCESS)
     71                throw CLError(error, "clGetPlatformInfoName");
     72           
     73            std::cout << "Platform: " << platformName.get() << "\n";
     74           
     75            // list devices, before it get GPU devices
     76            cl_uint devicesNum;
     77            std::unique_ptr<cl_device_id[]> devices;
     78            error = clGetDeviceIDs(choosenPlatform, CL_DEVICE_TYPE_GPU, 0,
     79                                nullptr, &devicesNum);
     80            if (error != CL_SUCCESS)
     81                throw CLError(error, "clGetDeviceIDs");
     82           
     83            devices.reset(new cl_device_id[devicesNum]);
     84            error = clGetDeviceIDs(choosenPlatform, CL_DEVICE_TYPE_GPU,
     85                            devicesNum, devices.get(), nullptr);
     86            if (error != CL_SUCCESS)
     87                throw CLError(error, "clGetDeviceIDs");
     88           
     89            for (cl_uint i = 0; i < devicesNum; i++)
     90            {
     91                cl_device_id device = devices[i];
     92                // get device and print that
     93                size_t deviceNameSize;
     94                std::unique_ptr<char[]> deviceName;
     95                error = clGetDeviceInfo(device, CL_DEVICE_NAME, 0, nullptr,
     96                                &deviceNameSize);
     97                if (error != CL_SUCCESS)
     98                    throw CLError(error, "clGetDeviceInfoName");
     99                deviceName.reset(new char[deviceNameSize]);
     100                error = clGetDeviceInfo(device, CL_DEVICE_NAME, deviceNameSize,
     101                                        deviceName.get(), nullptr);
     102                if (error != CL_SUCCESS)
     103                    throw CLError(error, "clGetDeviceInfoName");
     104                std::cout << "  Device: " << (i+devPlatformStart) << " - " <<
     105                            deviceName.get() << "\n";
     106            }
     107            devPlatformStart += devicesNum;
    87108        }
    88109        std::cout.flush();
     
    118139   
    119140    cl_int error = CL_SUCCESS;
    120     const cl_platform_id choosenPlatform = chooseCLPlatformForCLRX();
     141    const std::vector<cl_platform_id> choosenPlatforms = chooseCLPlatformsForCLRX();
    121142   
    122143    // find device
     144    cxuint devPlatformStart = 0;
    123145    cl_uint devicesNum;
     146    cl_platform_id choosenPlatform = nullptr;
    124147    std::unique_ptr<cl_device_id[]> devices;
    125     error = clGetDeviceIDs(choosenPlatform, CL_DEVICE_TYPE_GPU, 0, nullptr, &devicesNum);
    126     if (error != CL_SUCCESS)
    127         throw CLError(error, "clGetDeviceIDs");
    128    
    129     if (deviceIndex >= devicesNum)
     148    for (cl_platform_id platform: choosenPlatforms)
     149    {
     150        error = clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU,
     151                            0, nullptr, &devicesNum);
     152        if (error != CL_SUCCESS)
     153            throw CLError(error, "clGetDeviceIDs");
     154       
     155        if (deviceIndex - devPlatformStart < devicesNum)
     156        {
     157            choosenPlatform = platform;
     158            break;
     159        }
     160        devPlatformStart += devicesNum;
     161    }
     162    if (choosenPlatform == nullptr)
    130163        throw CLError(0, "DeviceIndexOutOfRange");
    131164       
     
    136169        throw CLError(error, "clGetDeviceIDs");
    137170   
    138     device = devices[deviceIndex];
     171    device = devices[deviceIndex-devPlatformStart];
    139172   
    140173    const CLAsmSetup asmSetup = assemblerSetupForCLDevice(device, useCL==1 ?
Note: See TracChangeset for help on using the changeset viewer.