Ignore:
Timestamp:
Dec 15, 2010, 12:46:24 PM (11 years ago)
Author:
Sven Rech
Message:

Some work on the external keysearcher client (not tested)

File:
1 edited

Legend:

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

    r2205 r2207  
    105105#define __NO_STD_STRING
    106106
    107 #include <CL/cl.hpp>
    108 
    109 #include "Job.h"
    110 int doOpenCLJob(const Job& j)
     107#include "Cryptool.h"
     108
     109Cryptool::Cryptool()
    111110{
    112111    cl_int err;
     112
     113    kernel = 0;
    113114
    114115    // Platform info
     
    119120    {
    120121        std::cerr << "Platform::get() failed (" << err << ")" << std::endl;
    121         return SDK_FAILURE;
     122        throw std::exception();
    122123    }
    123124
     
    136137    {
    137138        std::cerr << "Platform::getInfo() failed (" << err << ")" << std::endl;
    138         return SDK_FAILURE;
     139        throw std::exception();
    139140    }
    140141
     
    147148
    148149    std::cout<<"Creating a context AMD platform\n";
    149     cl::Context context(CL_DEVICE_TYPE_CPU, cps, NULL, NULL, &err);
     150    context = new cl::Context(CL_DEVICE_TYPE_CPU, cps, NULL, NULL, &err);
    150151    if (err != CL_SUCCESS) {
    151152        std::cerr << "Context::Context() failed (" << err << ")\n";
    152         return SDK_FAILURE;
     153        throw std::exception();
    153154    }
    154155
    155156    std::cout<<"Getting device info\n";
    156     cl::vector<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();
     157    devices = context->getInfo<CL_CONTEXT_DEVICES>();
    157158    if (err != CL_SUCCESS) {
    158159        std::cerr << "Context::getInfo() failed (" << err << ")\n";
    159         return SDK_FAILURE;
     160        throw std::exception();
    160161    }
    161162    if (devices.size() == 0) {
    162163        std::cerr << "No device available\n";
    163         return SDK_FAILURE;
     164        throw std::exception();
    164165    }
    165166
     
    174175        printf("version c: %s\n", out.c_str());
    175176    }
     177}
     178
     179void Cryptool::buildKernel(const Job& j)
     180{
     181    if (j.Src == "")
     182    {
     183        if (kernel != 0)
     184            return;
     185        else
     186        {
     187            std::cout << "Source transmission failure!" << std::endl;
     188            throw new std::exception();
     189        }
     190    }
     191
     192    cl_int err;
     193
    176194    std::cout<<"compiling CL source\n";
    177         cl::Program::Sources sources(1, std::make_pair(j.Src.c_str(), j.Src.length()));
    178 
    179         cl::Program program = cl::Program(context, sources, &err);
    180         if (err != CL_SUCCESS) {
     195    cl::Program::Sources sources(1, std::make_pair(j.Src.c_str(), j.Src.length()));
     196
     197    cl::Program program = cl::Program(*context, sources, &err);
     198    if (err != CL_SUCCESS) {
    181199        std::cerr << "Program::Program() failed (" << err << ")\n";
    182         return SDK_FAILURE;
     200        throw new std::exception();
    183201    }
    184202
     
    186204    if (err != CL_SUCCESS) {
    187205
    188                 if(err == CL_BUILD_PROGRAM_FAILURE)
     206        if(err == CL_BUILD_PROGRAM_FAILURE)
    189207        {
    190208            cl::string str = program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(devices[0]);
     
    197215
    198216        std::cerr << "Program::build() failed (" << err << ")\n";
    199         return SDK_FAILURE;
    200     }
    201 
    202     cl::Kernel kernel(program, "bruteforceKernel", &err);
     217        throw new std::exception();
     218    }
     219
     220    if (kernel != 0)
     221        delete kernel;
     222
     223    kernel = new cl::Kernel(program, "bruteforceKernel", &err);
    203224    if (err != CL_SUCCESS) {
    204225        std::cerr << "Kernel::Kernel() failed (" << err << ")\n";
    205         return SDK_FAILURE;
    206     }
    207 
    208     cl::CommandQueue queue(context, devices[0], 0, &err);
     226        throw new std::exception();
     227    }
     228}
     229
     230JobResult Cryptool::doOpenCLJob(const Job& j)
     231{
     232    cl_int err;
     233
     234    buildKernel(j);
     235
     236    cl::CommandQueue queue(*context, devices[0], 0, &err);
    209237    if (err != CL_SUCCESS) {
    210238        std::cerr << "CommandQueue::CommandQueue() failed (" << err << ")\n";
     239        throw new std::exception();
    211240    }
    212241
    213242    // key
    214     const char* strkey = "lol";
    215 
    216     cl::Buffer keybuffer = cl::Buffer(context, CL_MEM_READ_ONLY, sizeof(strkey), NULL, &err);
     243    cl::Buffer keybuffer = cl::Buffer(*context, CL_MEM_READ_ONLY, j.KeySize, NULL, &err);
    217244    if(err != CL_SUCCESS)
    218245    {
    219246        std::cerr << "Failed to allocate keybuffer(" << err << ")\n";
    220         return SDK_FAILURE;
    221     }
    222 
    223     err = queue.enqueueWriteBuffer(keybuffer, 1, 0, sizeof(strkey), strkey);
     247        throw new std::exception();
     248    }
     249
     250    err = queue.enqueueWriteBuffer(keybuffer, 1, 0, j.KeySize, j.Key);
    224251
    225252    if(err != CL_SUCCESS)
    226253    {
    227254        std::cerr << "Failed write to keybuffer(" << err << ")\n";
    228         return SDK_FAILURE;
    229     }
    230 
    231     err = kernel.setArg(0, keybuffer);
     255        throw new std::exception();
     256    }
     257
     258    err = kernel->setArg(0, keybuffer);
    232259    if (err != CL_SUCCESS) {
    233260        std::cerr << "Kernel::setArg() failed (" << err << ")\n";
    234         return SDK_FAILURE;
     261        throw new std::exception();
    235262    }
    236263
    237264    // results
    238     cl::Buffer entropies = cl::Buffer(context, CL_MEM_WRITE_ONLY, sizeof(float)*20, NULL, &err);
     265    cl::Buffer entropies = cl::Buffer(*context, CL_MEM_WRITE_ONLY, sizeof(float)*j.ResultSize, NULL, &err);
    239266
    240267    if(err != CL_SUCCESS)
    241268    {
    242269        std::cerr << "Failed allocate to entropybuffer(" << err << ")\n";
    243         return SDK_FAILURE;
    244     }
    245 
    246     err = kernel.setArg(1, entropies);
     270        throw new std::exception();
     271    }
     272
     273    err = kernel->setArg(1, entropies);
    247274
    248275    if (err != CL_SUCCESS) {
    249276        std::cerr << "Kernel::setArg() failed (" << err << ")\n";
    250         return SDK_FAILURE;
    251     }
    252 
    253 
     277        throw new std::exception();
     278    }
     279
     280    //execute:
    254281    std::cout<<"Running CL program\n";
    255282    err = queue.enqueueNDRangeKernel(
    256         kernel, cl::NullRange, cl::NDRange(4, 4), cl::NDRange(2, 2)
     283        *kernel, cl::NullRange, cl::NDRange(4, 4), cl::NDRange(2, 2)
    257284    );
    258285
     
    260287        std::cerr << "CommandQueue::enqueueNDRangeKernel()" \
    261288            " failed (" << err << ")\n";
    262        return SDK_FAILURE;
     289        throw new std::exception();
    263290    }
    264291
     
    266293    if (err != CL_SUCCESS) {
    267294        std::cerr << "Event::wait() failed (" << err << ")\n";
    268         return SDK_FAILURE;
     295        throw new std::exception();
    269296    }
    270297
    271298    std::cout<<"Done\nPassed!\n";
    272299
    273     float localEntropy[20] = {};
    274 
    275     queue.enqueueReadBuffer(entropies, 1, 0, sizeof(float)*20, localEntropy);
    276 
    277     for(int i=0; i<20; ++i)
    278     {
    279         printf("Entropy[%i]=%f\n", i, localEntropy[i]);
    280     }
    281     return SDK_SUCCESS;
    282 }
     300    float* localEntropy = new float[j.ResultSize];
     301
     302    queue.enqueueReadBuffer(entropies, 1, 0, sizeof(float)*j.ResultSize, localEntropy);
     303
     304    //check results:
     305    JobResult res;
     306    res.ResultList.resize(j.ResultSize);
     307    initTop(res.ResultList, j.LargerThen);
     308
     309    for(int i=0; i<j.Size; ++i)
     310    {
     311        std::list<std::pair<float, int> >::iterator it = isInTop(res.ResultList, localEntropy[i], j.LargerThen);
     312        if (it != res.ResultList.end())
     313            pushInTop(res.ResultList, it, localEntropy[i], i);
     314    }
     315
     316    return res;
     317}
     318
     319
     320
     321void Cryptool::pushInTop(std::list<std::pair<float, int> >& top, std::list<std::pair<float, int> >::iterator it, float val, int k) {
     322        top.insert(it, std::pair<float, int>(val, k));
     323        top.pop_back();
     324}
     325
     326std::list<std::pair<float, int> >::iterator Cryptool::isInTop(std::list<std::pair<float, int> >& top, float val, bool LargerThen) {
     327        if (LargerThen)
     328        {
     329                for (std::list<std::pair<float, int> >::iterator k = top.begin(); k != top.end(); k++)
     330                        if (val > k->first)
     331                                return k;
     332        }
     333        else
     334        {
     335                for (std::list<std::pair<float, int> >::iterator k = top.begin(); k != top.end(); k++)
     336                        if (val < k->first)
     337                                return k;
     338        }
     339
     340        return top.end();
     341}
     342
     343void Cryptool::initTop(std::list<std::pair<float, int> >& top, bool LargerThen) {
     344        for (std::list<std::pair<float, int> >::iterator k = top.begin(); k != top.end(); k++)
     345        {
     346            if (LargerThen)
     347                k->first = -1000000.0;
     348            else
     349                k->first = 1000000.0;
     350        }
     351}
Note: See TracChangeset for help on using the changeset viewer.