void OpenCLScheduler::initialize(const int channels) {
// multi-gpu?
if (!cfg_gpus.empty()) {
auto silent{false};
for (auto gpu : cfg_gpus) {
auto opencl = std::make_unique<OpenCL>();
auto net = std::make_unique<OpenCL_Network>(*opencl);
opencl->initialize(channels, {gpu}, silent);
m_opencl.push_back(std::move(opencl));
m_networks.push_back(std::move(net));
// Clear thread data on every init call. We don't know which GPU
// this thread will be eventually be assigned to
opencl_thread_data = ThreadData();
// starting next GPU, let's not dump full list of GPUs
silent = true;
}
for (size_t gnum = 0; gnum < m_networks.size(); gnum++) {
// launch the worker thread. 2 threads so that we can fully
// utilize GPU, since the worker thread consists of some CPU
// work for task preparation.
constexpr auto num_threads = 2;
for (auto i = 0; i < num_threads; i++) {
m_threadpool.add_thread([gnum] {
current_thread_gpu_num = gnum;
});
}
}
} else {
auto opencl = std::make_unique<OpenCL>();
auto net = std::make_unique<OpenCL_Network>(*opencl);
opencl->initialize(channels, {});
m_opencl.push_back(std::move(opencl));
m_networks.push_back(std::move(net));
}
}
ThreadData ThreadsHandler::thread(ThreadId id) const
{
const int i = indexOf(id);
return i == -1 ? ThreadData() : m_threads.at(i);
}
bool UpdateFromEvent(DEBUG_EVENT& evt, DumpData& data)
{
switch(evt.dwDebugEventCode)
{
case CREATE_PROCESS_DEBUG_EVENT:
{
data.ProcessPath.resize(MAX_PATH);
DWORD len = GetModuleFileNameExA(evt.u.CreateProcessInfo.hProcess, NULL, &data.ProcessPath[0], data.ProcessPath.size());
if (len)
{
data.ProcessPath.resize(len);
std::string::size_type pos = data.ProcessPath.find_last_of("\\/");
if (pos != std::string::npos)
data.ProcessName = data.ProcessPath.substr(pos+1);
}
else
{
data.ProcessPath = "??";
}
if (data.ProcessName.empty())
data.ProcessName = data.ProcessPath;
CloseHandle(evt.u.CreateProcessInfo.hFile);
data.ProcessID = evt.dwProcessId;
data.ProcessHandle = evt.u.CreateProcessInfo.hProcess;
data.Threads[evt.dwThreadId] = ThreadData(evt.u.CreateProcessInfo.hThread);
}
break;
case CREATE_THREAD_DEBUG_EVENT:
data.Threads[evt.dwThreadId] = ThreadData(evt.u.CreateThread.hThread);
break;
case EXIT_THREAD_DEBUG_EVENT:
{
ThreadMap::iterator it = data.Threads.find(evt.dwThreadId);
if (it != data.Threads.end())
{
data.Threads.erase(it);
}
}
break;
case LOAD_DLL_DEBUG_EVENT:
CloseHandle(evt.u.LoadDll.hFile);
for (size_t n = 0; n < data.Modules.size(); ++n)
{
if (data.Modules[n].BaseAddress == evt.u.LoadDll.lpBaseOfDll)
{
data.Modules[n].Unloaded = false;
return true;
}
}
data.Modules.push_back(ModuleData(evt.u.LoadDll.lpBaseOfDll));
break;
case UNLOAD_DLL_DEBUG_EVENT:
for (size_t n = 0; n < data.Modules.size(); ++n)
{
if (data.Modules[n].BaseAddress == evt.u.UnloadDll.lpBaseOfDll)
data.Modules[n].Unloaded = true;
}
break;
case OUTPUT_DEBUG_STRING_EVENT: // ignore
break;
case EXCEPTION_DEBUG_EVENT:
if (evt.u.Exception.dwFirstChance)
{
switch(evt.u.Exception.ExceptionRecord.ExceptionCode)
{
case EXCEPTION_BREAKPOINT:
if (!data.FirstBPHit)
{
data.FirstBPHit = true;
if (data.Event)
{
SetEvent(data.Event);
CloseHandle(data.Event);
data.Event = NULL;
}
return true;
}
break;
case MS_VC_EXCEPTION_THREAD_NAME:
/* Thread name */
return true;
case DBG_CONTROL_C:
case DBG_CONTROL_BREAK:
return true;
}
}
data.ExceptionInfo = evt.u.Exception;
data.ThreadID = evt.dwThreadId;
return false;
case EXIT_PROCESS_DEBUG_EVENT:
//assert(FALSE);
return false;
case RIP_EVENT:
//assert(FALSE);
return false;
default:
assert(false);
}
return true;
}
virtual ScheduleThreadData * createThreadData ()
{
return NEW ThreadData();
}
