Changeset 2486


Ignore:
Timestamp:
Jan 25, 2011, 11:09:18 PM (10 years ago)
Author:
schwittmann
Message:

Improved external client:

  • added possibility to choose device
  • added verbose device information
  • added device name to identification
  • misc cleanup
Location:
trunk/CrypPlugins/KeySearcher/ExternalClient
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/KeySearcher/ExternalClient/Cryptool.cpp

    r2411 r2486  
    1212#endif
    1313
    14 #define __NO_STD_VECTOR
    1514#define __NO_STD_STRING
    1615
     
    2726
    2827    kernel = 0;
    29 
    30     // Platform info
    31     cl::vector<cl::Platform> platforms;
    32     std::cout<<"HelloCL!\nGetting Platform Information\n";
     28    platformChoice = -1;
     29    deviceChoice = -1;
     30
     31    // Get platform information
     32    std::cout<<"Getting platform"<<std::endl;
    3333    err = cl::Platform::get(&platforms);
     34
    3435    if(err != CL_SUCCESS)
    3536    {
     
    3738        throw std::exception();
    3839    }
    39     if (platforms.size() == 0)
     40    if (platforms.size() <= 0)
    4041    {
    4142        std::cerr << "No platforms available!" << std::endl;
     
    4344    }
    4445
    45     cl::vector<cl::Platform>::iterator i;
    46     if(platforms.size() > 0)
    47     {
    48         for(i = platforms.begin(); i != platforms.end(); ++i)
    49         {
    50             if(!strcmp((*i).getInfo<CL_PLATFORM_VENDOR>(&err).c_str(), "Advanced Micro Devices, Inc."))
    51             {
    52                 break;
    53             }
    54         }
    55     }
    56     if(err != CL_SUCCESS)
    57     {
    58         std::cerr << "Platform::getInfo() failed (" << err << ")" << std::endl;
    59         throw std::exception();
    60     }
     46    //Iterate over all platforms to generate output for platform choosing by user
     47    std::vector<cl::Platform>::iterator i;
     48        std::cout << "Number of platforms: " << platforms.size() << std::endl << std::endl;
     49        for(i = platforms.begin(); i != platforms.end(); ++i)
     50        {
     51                std::cout << "Platform Profile: " << (*i).getInfo<CL_PLATFORM_PROFILE>(&err).c_str() << std::endl;
     52                std::cout << "Platform Version: " << (*i).getInfo<CL_PLATFORM_VERSION>(&err).c_str() << std::endl;
     53                std::cout << "Platform Name: " << (*i).getInfo<CL_PLATFORM_NAME>(&err).c_str() << std::endl;
     54                std::cout << "Platform Vendor: " << (*i).getInfo<CL_PLATFORM_VENDOR>(&err).c_str() << std::endl;
     55                std::cout << std::endl;
     56
     57            if(err != CL_SUCCESS)
     58            {
     59                std::cerr << "Platform::getInfo() failed (" << err << ")" << std::endl;
     60                throw std::exception();
     61            }
     62
     63            //Get all devices for the current platform to show device information for each device
     64                (*i).getDevices((cl_device_type)CL_DEVICE_TYPE_ALL, &devices);
     65
     66                std::cout << "There are " << devices.size() << " devices for this platform." <<std::endl;
     67
     68                for (std::vector<cl::Device>::iterator z = devices.begin(); z != devices.end(); ++z) {
     69                        cl_device_type dtype = (*z).getInfo<CL_DEVICE_TYPE>();
     70                        std::cout << "  Device Type: ";
     71                        switch (dtype) {
     72                                case CL_DEVICE_TYPE_ACCELERATOR:
     73                                        std::cout << "CL_DEVICE_TYPE_ACCELERATOR" << std::endl;
     74                                        break;
     75                                case CL_DEVICE_TYPE_CPU:
     76                                        std::cout << "CL_DEVICE_TYPE_CPU" << std::endl;
     77                                        break;
     78                                case CL_DEVICE_TYPE_DEFAULT:
     79                                        std::cout << "CL_DEVICE_TYPE_DEFAULT" << std::endl;
     80                                        break;
     81                                case CL_DEVICE_TYPE_GPU:
     82                                        std::cout << "CL_DEVICE_TYPE_GPU" << std::endl;
     83                                        break;
     84                                }
     85
     86            std::cout << "  Platform ID: " << (*z).getInfo<CL_DEVICE_PLATFORM>() << std::endl;
     87            std::cout << "  Name: " << (*z).getInfo<CL_DEVICE_NAME>().c_str() << std::endl;
     88            std::cout << "  Vendor: " << (*z).getInfo<CL_DEVICE_VENDOR>().c_str() << std::endl;
     89            std::cout << "  Driver version: " << (*z).getInfo<CL_DRIVER_VERSION>().c_str() << std::endl;
     90            std::cout << "  Is device available?  " << ((*z).getInfo<CL_DEVICE_AVAILABLE>() ? "Yes" : "No") << std::endl;
     91            std::cout << "  Device ID: " << (*z).getInfo<CL_DEVICE_VENDOR_ID>() << std::endl;
     92            std::cout << "  Max clock frequency: " << (*z).getInfo<CL_DEVICE_MAX_CLOCK_FREQUENCY>() << "Mhz" << std::endl;
     93            std::cout << "  Local memory size: " << (*z).getInfo<CL_DEVICE_LOCAL_MEM_SIZE>() << std::endl;
     94            std::cout << "  Global memory size: " << (*z).getInfo<CL_DEVICE_GLOBAL_MEM_SIZE>() << std::endl;
     95            std::cout << "  Max memory allocation: " << (*z).getInfo<CL_DEVICE_MAX_MEM_ALLOC_SIZE>() << std::endl;
     96            std::cout << "  Cache size: " << (*z).getInfo<CL_DEVICE_GLOBAL_MEM_CACHE_SIZE>() << std::endl;
     97            std::cout << "  Extensions: " << (*z).getInfo<CL_DEVICE_EXTENSIONS>().c_str() << std::endl;
     98            std::cout << "  Execution capabilities: " << std::endl;
     99            std::cout << "    Execute OpenCL kernels: " << ((*z).getInfo<CL_DEVICE_EXECUTION_CAPABILITIES>() & CL_EXEC_KERNEL ? "Yes" : "No") << std::endl;
     100            std::cout << "    Execute native function: " << ((*z).getInfo<CL_DEVICE_EXECUTION_CAPABILITIES>() & CL_EXEC_NATIVE_KERNEL ? "Yes" : "No") << std::endl;
     101
     102                        std::cout << std::endl;
     103                }
     104        }
     105
     106        if(platforms.size() > 1) {
     107                while(platformChoice<0 || platformChoice>=(int)platforms.size()) {
     108                        std::cout << "Choose your platform!" << std::endl;
     109                        std::cin >> platformChoice;
     110                }
     111        } else {
     112                std::cout << "Choosing only available platform." << std::endl;
     113                platformChoice=0;
     114        }
     115
     116        if(devices.size() > 1) {
     117                while(deviceChoice<0 || deviceChoice>=(int)devices.size()) {
     118                        std::cout << "Choose the device to calculate on!" << std::endl;
     119                        std::cin >> deviceChoice;
     120                }
     121        } else {
     122                std::cout << "Choosing only available device." << std::endl;
     123                deviceChoice=0;
     124        }
     125
    61126
    62127    /*
     
    65130     */
    66131
    67     cl_context_properties cps[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)(*i)(), 0 };
    68 
    69     std::cout<<"Creating a context AMD platform\n";
    70     context = new cl::Context(CL_DEVICE_TYPE_CPU, cps, NULL, NULL, &err);
     132    cl_context_properties cps[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platforms.at(platformChoice)(), 0 };
     133
     134    std::cout<<"Creating CL context" << std::endl;
     135    context = new cl::Context(CL_DEVICE_TYPE_ALL, cps, NULL, NULL, &err);
     136
    71137    if (err != CL_SUCCESS) {
    72138        std::cerr << "Context::Context() failed (" << err << ")\n";
    73139        throw std::exception();
    74140    }
    75 
    76     std::cout<<"Getting device info\n";
    77     devices = context->getInfo<CL_CONTEXT_DEVICES>();
    78     if (err != CL_SUCCESS) {
    79         std::cerr << "Context::getInfo() failed (" << err << ")\n";
    80         throw std::exception();
    81     }
    82     if (devices.size() == 0) {
    83         std::cerr << "No device available\n";
    84         throw std::exception();
    85     }
    86 
    87     for(uint32_t i=0; i< devices.size(); ++i)
    88     {
    89         std::string out;
    90         devices[i].getInfo(CL_DEVICE_NAME, &out);
    91         printf("name: %s\n", out.c_str());
    92         devices[i].getInfo(CL_DEVICE_VENDOR, &out);
    93         printf("vendor: %s\n", out.c_str());
    94         devices[i].getInfo(CL_DEVICE_OPENCL_C_VERSION, &out);
    95         printf("version c: %s\n", out.c_str());
    96     }
    97 
     141   
    98142    // results
    99143    costs = cl::Buffer(*context, CL_MEM_WRITE_ONLY, sizeof(float)*subbatch, NULL, &err);
     
    128172    cl_int err;
    129173
    130     std::cout<<"compiling CL source\n";
     174    std::cout<<"Compiling CL source\n";
    131175    cl::Program::Sources sources(1, std::make_pair(j.Src.c_str(), j.Src.length()));
    132176
     
    140184    if (err != CL_SUCCESS) {
    141185
    142         if(err == CL_BUILD_PROGRAM_FAILURE)
    143         {
    144             cl::string str = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(devices[0]);
    145 
    146             std::cout << " \n\t\t\tBUILD LOG\n";
    147             std::cout << " ************************************************\n";
    148                         std::cout << str.c_str() << std::endl;
    149             std::cout << " ************************************************\n";
    150         }
    151 
     186                if(err == CL_BUILD_PROGRAM_FAILURE)
     187                        {
     188                                cl::string str = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(devices[0]);
     189
     190                                std::cout << " \n\t\t\tBUILD LOG\n";
     191                                std::cout << " ************************************************\n";
     192                                std::cout << str.c_str() << std::endl;
     193                                std::cout << " ************************************************\n";
     194                        }
     195
     196                //If there is an -33 error thrown here, you are most commonly trying to run an unsupported OpenCL version
    152197        std::cerr << "Program::build() failed (" << err << ")\n";
    153198        throw std::exception();
     
    171216    buildKernel(j);
    172217
    173     cl::CommandQueue queue(*context, devices[0], 0, &err);
     218    std::cout << "Using device named: " << getDeviceName() << " to calculate." << std::endl;
     219    //Use the chosen device to calculate on!
     220    cl::CommandQueue queue(*context, devices[deviceChoice], 0, &err);
    174221    if (err != CL_SUCCESS) {
    175222        std::cerr << "CommandQueue::CommandQueue() failed (" << err << ")\n";
     
    364411        }
    365412}
     413
     414std::string Cryptool::getDeviceName()
     415{
     416    return std::string(devices[deviceChoice].getInfo<CL_DEVICE_NAME>().c_str());
     417}
  • trunk/CrypPlugins/KeySearcher/ExternalClient/Cryptool.h

    r2258 r2486  
    99{
    1010    private:
    11         cl::vector<cl::Device> devices;
     11        std::vector<cl::Platform> platforms;
     12        std::vector<cl::Device> devices;
    1213        cl::Context* context;
    1314        cl::Kernel* kernel;
     
    1718    bool compareLargerThan;
    1819    int resultSize;
     20    int platformChoice;
     21    int deviceChoice;
    1922    timeval lastSubbatchCompleted;
    2023
     
    3033        Cryptool();
    3134        JobResult doOpenCLJob(const Job& j);
     35    std::string getDeviceName();
    3236};
  • trunk/CrypPlugins/KeySearcher/ExternalClient/Network.cpp

    r2450 r2486  
    3030        out << buf;
    3131    }
    32     out << "@";
    33     out << sysconf( _SC_NPROCESSORS_ONLN );
    34     out << "cores";
    35     // todo: more
     32    else
     33    {
     34        out << "unkhost";
     35    }
     36    out << "/";
     37    const char* devicename = cryptool->getDeviceName().c_str();
     38
     39    const std::string whitespaces = " \t\r\n";
     40
     41    while(*devicename)
     42    {
     43        if(whitespaces.find(*devicename) == std::string::npos)
     44        {
     45            out << *devicename;
     46        }
     47        ++devicename;
     48    }
    3649    return out.str();
    3750}
Note: See TracChangeset for help on using the changeset viewer.