static bool opencl_thread_prepare(struct thr_info *thr)
{
char name[256];
struct timeval now;
struct cgpu_info *cgpu = thr->cgpu;
int gpu = cgpu->device_id;
int virtual_gpu = cgpu->virtual_gpu;
int i = thr->id;
static bool failmessage = false;
int buffersize = BUFFERSIZE;
if (!blank_res)
blank_res = (uint32_t *)calloc(buffersize, 1);
if (!blank_res) {
applog(LOG_ERR, "Failed to calloc in opencl_thread_init");
return false;
}
strcpy(name, "");
applog(LOG_INFO, "Init GPU thread %i GPU %i virtual GPU %i", i, gpu, virtual_gpu);
clStates[i] = initCl(virtual_gpu, name, sizeof(name), &cgpu->algorithm);
if (!clStates[i]) {
#ifdef HAVE_CURSES
if (use_curses)
enable_curses();
#endif
applog(LOG_ERR, "Failed to init GPU thread %d, disabling device %d", i, gpu);
if (!failmessage) {
applog(LOG_ERR, "Restarting the GPU from the menu will not fix this.");
applog(LOG_ERR, "Re-check your configuration and try restarting.");
failmessage = true;
#ifdef HAVE_CURSES
char *buf;
if (use_curses) {
buf = curses_input("Press enter to continue");
if (buf)
free(buf);
}
#endif
}
cgpu->deven = DEV_DISABLED;
cgpu->status = LIFE_NOSTART;
dev_error(cgpu, REASON_DEV_NOSTART);
return false;
}
if (!cgpu->name)
cgpu->name = strdup(name);
if (!cgpu->kernelname)
cgpu->kernelname = strdup("ckolivas");
applog(LOG_INFO, "initCl() finished. Found %s", name);
cgtime(&now);
get_datestamp(cgpu->init, sizeof(cgpu->init), &now);
have_opencl = true;
return true;
}
void Scene::ensureCl(){
#ifdef WOO_OPENCL
if(_clDev[0]<0) initCl(); // no device really initialized
return;
#else
throw std::runtime_error("Yade was compiled without OpenCL support (add to features and recompile).");
#endif
}
void Scene::postLoad(Scene&,void*){
if(!clock0adjusted){
clock0-=boost::posix_time::seconds(preSaveDuration);
clock0adjusted=true;
}
#ifdef WOO_OPENCL
// clDev is set and does not match really initialized device in _clDev
if(clDev[0]!=_clDev[0] || clDev[1]!=_clDev[1]) initCl();
#else
if(clDev[0]>=0) ensureCl(); // only throws
#endif
if(!plot){
LOG_WARN("Scene.plot==None is disallowed, assigning woo.core.Plot().");
plot=make_shared<Plot>();
}
if(plot->scene.lock() && (plot->scene.lock().get()!=this)){
// this happens e.g. when reloading scene and should not be a reason for warning
// LOG_WARN("woo.core.Plot object belonging to another Scene? Reassigning.");
}
plot->scene=static_pointer_cast<Scene>(shared_from_this());
if(ctrl) ctrl->scene=static_pointer_cast<Scene>(shared_from_this());
//
// assign fields to engines
int i=0;
for(const shared_ptr<Engine>& e: engines){
if(!e) throw std::runtime_error("Scene.engines["+to_string(i)+"]==None (not allowed).");
//cerr<<e->getClassName()<<endl;
e->scene=this;
e->setField();
i++;
}
// TODO: this can be removed, as labels should be saved just fine
// manage labeled engines
for(const shared_ptr<Engine>& e: engines){
Engine::handlePossiblyLabeledObject(e,labels);
e->getLabeledObjects(labels);
}
}
static bool opencl_thread_prepare(struct thr_info *thr)
{
char name[256];
struct timeval now;
struct cgpu_info *cgpu = thr->cgpu;
int gpu = cgpu->device_id;
int virtual_gpu = cgpu->virtual_gpu;
int i = thr->id;
static bool failmessage = false;
if (!blank_res)
blank_res = calloc(BUFFERSIZE, 1);
if (!blank_res) {
applog(LOG_ERR, "Failed to calloc in opencl_thread_init");
return false;
}
strcpy(name, "");
applog(LOG_INFO, "Init GPU thread %i GPU %i virtual GPU %i", i, gpu, virtual_gpu);
clStates[i] = initCl(virtual_gpu, name, sizeof(name));
if (!clStates[i]) {
#ifdef HAVE_CURSES
if (use_curses)
enable_curses();
#endif
applog(LOG_ERR, "Failed to init GPU thread %d, disabling device %d", i, gpu);
if (!failmessage) {
applog(LOG_ERR, "Restarting the GPU from the menu will not fix this.");
applog(LOG_ERR, "Try restarting cgminer.");
failmessage = true;
#ifdef HAVE_CURSES
char *buf;
if (use_curses) {
buf = curses_input("Press enter to continue");
if (buf)
free(buf);
}
#endif
}
cgpu->deven = DEV_DISABLED;
cgpu->status = LIFE_NOSTART;
dev_error(cgpu, REASON_DEV_NOSTART);
return false;
}
if (!cgpu->name)
cgpu->name = strdup(name);
if (!cgpu->kname)
{
switch (clStates[i]->chosen_kernel) {
case KL_DIABLO:
cgpu->kname = "diablo";
break;
case KL_DIAKGCN:
cgpu->kname = "diakgcn";
break;
case KL_PHATK:
cgpu->kname = "phatk";
break;
#ifdef USE_SCRYPT
case KL_SCRYPT:
cgpu->kname = "scrypt";
break;
#endif
case KL_POCLBM:
cgpu->kname = "poclbm";
break;
default:
break;
}
}
applog(LOG_INFO, "initCl() finished. Found %s", name);
gettimeofday(&now, NULL);
get_datestamp(cgpu->init, &now);
have_opencl = true;
return true;
}
/* We have only one thread that ever re-initialises GPUs, thus if any GPU
* init command fails due to a completely wedged GPU, the thread will never
* return, unable to harm other GPUs. If it does return, it means we only had
* a soft failure and then the reinit_gpu thread is ready to tackle another
* GPU */
void *reinit_gpu(void *userdata)
{
struct thr_info *mythr = userdata;
struct cgpu_info *cgpu;
struct thr_info *thr;
struct timeval now;
char name[256];
int thr_id;
int gpu;
pthread_detach(pthread_self());
select_cgpu:
cgpu = tq_pop(mythr->q, NULL);
if (!cgpu)
goto out;
if (clDevicesNum() != nDevs) {
applog(LOG_WARNING, "Hardware not reporting same number of active devices, will not attempt to restart GPU");
goto out;
}
gpu = cgpu->device_id;
for (thr_id = 0; thr_id < mining_threads; ++thr_id) {
thr = &thr_info[thr_id];
cgpu = thr->cgpu;
if (cgpu->api != &opencl_api)
continue;
if (dev_from_id(thr_id) != gpu)
continue;
thr = &thr_info[thr_id];
if (!thr) {
applog(LOG_WARNING, "No reference to thread %d exists", thr_id);
continue;
}
thr->rolling = thr->cgpu->rolling = 0;
/* Reports the last time we tried to revive a sick GPU */
gettimeofday(&thr->sick, NULL);
if (!pthread_cancel(thr->pth)) {
applog(LOG_WARNING, "Thread %d still exists, killing it off", thr_id);
} else
applog(LOG_WARNING, "Thread %d no longer exists", thr_id);
}
for (thr_id = 0; thr_id < mining_threads; ++thr_id) {
int virtual_gpu;
thr = &thr_info[thr_id];
cgpu = thr->cgpu;
if (cgpu->api != &opencl_api)
continue;
if (dev_from_id(thr_id) != gpu)
continue;
virtual_gpu = cgpu->virtual_gpu;
/* Lose this ram cause we may get stuck here! */
//tq_freeze(thr->q);
thr->q = tq_new();
if (!thr->q)
quit(1, "Failed to tq_new in reinit_gpu");
/* Lose this ram cause we may dereference in the dying thread! */
//free(clState);
applog(LOG_INFO, "Reinit GPU thread %d", thr_id);
clStates[thr_id] = initCl(virtual_gpu, name, sizeof(name));
if (!clStates[thr_id]) {
applog(LOG_ERR, "Failed to reinit GPU thread %d", thr_id);
goto select_cgpu;
}
applog(LOG_INFO, "initCl() finished. Found %s", name);
if (unlikely(thr_info_create(thr, NULL, miner_thread, thr))) {
applog(LOG_ERR, "thread %d create failed", thr_id);
return NULL;
}
applog(LOG_WARNING, "Thread %d restarted", thr_id);
}
gettimeofday(&now, NULL);
get_datestamp(cgpu->init, &now);
for (thr_id = 0; thr_id < mining_threads; ++thr_id) {
thr = &thr_info[thr_id];
cgpu = thr->cgpu;
if (cgpu->api != &opencl_api)
continue;
if (dev_from_id(thr_id) != gpu)
continue;
tq_push(thr->q, &ping);
}
goto select_cgpu;
out:
return NULL;
}
static bool opencl_thread_prepare(struct thr_info *thr)
{
char name[256];
struct timeval now;
struct cgpu_info *cgpu = thr->cgpu;
int gpu = cgpu->device_id;
int virtual_gpu = cgpu->virtual_gpu;
int i = thr->id;
static bool failmessage = false;
int buffersize = BUFFERSIZE;
if (!blank_res)
blank_res = calloc(buffersize, 1);
if (!blank_res) {
applog(LOG_ERR, "Failed to calloc in opencl_thread_init");
return false;
}
strcpy(name, "");
applog(LOG_INFO, "Init GPU thread %i GPU %i virtual GPU %i", i, gpu, virtual_gpu);
clStates[i] = initCl(virtual_gpu, name, sizeof(name));
if (!clStates[i]) {
#ifdef HAVE_CURSES
if (use_curses)
enable_curses();
#endif
applog(LOG_ERR, "Failed to init GPU thread %d, disabling device %d", i, gpu);
if (!failmessage) {
applog(LOG_ERR, "Restarting the GPU from the menu will not fix this.");
applog(LOG_ERR, "Try restarting sgminer.");
failmessage = true;
#ifdef HAVE_CURSES
char *buf;
if (use_curses) {
buf = curses_input("Press enter to continue");
if (buf)
free(buf);
}
#endif
}
cgpu->deven = DEV_DISABLED;
cgpu->status = LIFE_NOSTART;
dev_error(cgpu, REASON_DEV_NOSTART);
return false;
}
if (!cgpu->name)
cgpu->name = strdup(name);
if (!cgpu->kname)
{
switch (clStates[i]->chosen_kernel) {
case KL_ALEXKARNEW:
cgpu->kname = ALEXKARNEW_KERNNAME;
break;
case KL_ALEXKAROLD:
cgpu->kname = ALEXKAROLD_KERNNAME;
break;
case KL_CKOLIVAS:
cgpu->kname = CKOLIVAS_KERNNAME;
break;
case KL_ZUIKKIS:
cgpu->kname = ZUIKKIS_KERNNAME;
break;
case KL_PSW:
cgpu->kname = PSW_KERNNAME;
break;
case KL_DARKCOIN:
cgpu->kname = DARKCOIN_KERNNAME;
break;
case KL_QUBITCOIN:
cgpu->kname = QUBITCOIN_KERNNAME;
break;
case KL_QUARKCOIN:
cgpu->kname = QUARKCOIN_KERNNAME;
break;
default:
break;
}
}
applog(LOG_INFO, "initCl() finished. Found %s", name);
cgtime(&now);
get_datestamp(cgpu->init, sizeof(cgpu->init), &now);
return true;
}
/* We have only one thread that ever re-initialises GPUs, thus if any GPU
* init command fails due to a completely wedged GPU, the thread will never
* return, unable to harm other GPUs. If it does return, it means we only had
* a soft failure and then the reinit_gpu thread is ready to tackle another
* GPU */
void *reinit_gpu(void *userdata)
{
struct thr_info *mythr = (struct thr_info *)userdata;
struct cgpu_info *cgpu;
struct thr_info *thr;
struct timeval now;
char name[256];
int thr_id;
int gpu;
pthread_detach(pthread_self());
select_cgpu:
cgpu = (struct cgpu_info *)tq_pop(mythr->q, NULL);
if (!cgpu)
goto out;
if (clDevicesNum() != nDevs) {
applog(LOG_WARNING, "Hardware not reporting same number of active devices, will not attempt to restart GPU");
goto out;
}
gpu = cgpu->device_id;
rd_lock(&mining_thr_lock);
for (thr_id = 0; thr_id < mining_threads; ++thr_id) {
thr = mining_thr[thr_id];
cgpu = thr->cgpu;
if (cgpu->drv->drv_id != DRIVER_opencl)
continue;
if (dev_from_id(thr_id) != gpu)
continue;
thr->rolling = thr->cgpu->rolling = 0;
/* Reports the last time we tried to revive a sick GPU */
cgtime(&thr->sick);
if (!pthread_kill(thr->pth, 0)) {
applog(LOG_WARNING, "Thread %d still exists, killing it off", thr_id);
cg_completion_timeout(&thr_info_cancel_join, thr, 5000);
thr->cgpu->drv->thread_shutdown(thr);
} else
applog(LOG_WARNING, "Thread %d no longer exists", thr_id);
}
rd_unlock(&mining_thr_lock);
rd_lock(&mining_thr_lock);
for (thr_id = 0; thr_id < mining_threads; ++thr_id) {
int virtual_gpu;
thr = mining_thr[thr_id];
cgpu = thr->cgpu;
if (cgpu->drv->drv_id != DRIVER_opencl)
continue;
if (dev_from_id(thr_id) != gpu)
continue;
virtual_gpu = cgpu->virtual_gpu;
/* Lose this ram cause we may get stuck here! */
//tq_freeze(thr->q);
thr->q = tq_new();
if (!thr->q)
quit(1, "Failed to tq_new in reinit_gpu");
/* Lose this ram cause we may dereference in the dying thread! */
//free(clState);
applog(LOG_INFO, "Reinit GPU thread %d", thr_id);
clStates[thr_id] = initCl(virtual_gpu, name, sizeof(name), &cgpu->algorithm);
if (!clStates[thr_id]) {
applog(LOG_ERR, "Failed to reinit GPU thread %d", thr_id);
goto select_cgpu;
}
applog(LOG_INFO, "initCl() finished. Found %s", name);
if (unlikely(thr_info_create(thr, NULL, miner_thread, thr))) {
applog(LOG_ERR, "thread %d create failed", thr_id);
return NULL;
}
applog(LOG_WARNING, "Thread %d restarted", thr_id);
}
rd_unlock(&mining_thr_lock);
cgtime(&now);
get_datestamp(cgpu->init, sizeof(cgpu->init), &now);
rd_lock(&mining_thr_lock);
for (thr_id = 0; thr_id < mining_threads; ++thr_id) {
thr = mining_thr[thr_id];
cgpu = thr->cgpu;
if (cgpu->drv->drv_id != DRIVER_opencl)
continue;
if (dev_from_id(thr_id) != gpu)
continue;
cgsem_post(&thr->sem);
}
rd_unlock(&mining_thr_lock);
goto select_cgpu;
out:
return NULL;
}
void init()
{
const unsigned screenDivide = 1;
const unsigned incoreBufferSizeInByte = 512/*MB*/ * 1024 * 1024;
g_bufferWidth = g_screenWidth / (float)screenDivide;
g_bufferHeight = g_screenHeight / (float)screenDivide;
// load svo
const std::string svo_dir_path = "/home/fweissig/Data/SVO_DATA/";
// const std::string svo_dir_path = "/home/otaco/Desktop/SVO_DATA/";
// g_svoBaseName = "frog2_seperated_s8_d7";
// g_svoBaseName = "TreeletBuildManager_out";
// g_svoBaseName = "lucy_s2_d11";
// g_svoBaseName = "david_2mm_final_ao_s4_d11";
// g_svoBaseName = "david_face_s1_D13";
// g_svoBaseName = "david_face_s4_D13";
// g_svoBaseName = "lucy_s1_D13";
// g_svoBaseName = "lucy_s4_D13";
// g_svoBaseName = "xyzrgb_statuette_s1_D13";
// g_svoBaseName = "xyzrgb_statuette_s4_D13";
g_texter = new gloost::TextureText(g_gloostFolder + "/data/fonts/gloost_Fixedsys_16_gui.png");
// setup framebuffer
std::cerr << std::endl;
std::cerr << std::endl << "Setting up framebuffer: ";
std::cerr << std::endl << " width: " << g_bufferWidth;
std::cerr << std::endl << " height: " << g_bufferHeight;
std::cerr << std::endl;
gloost::gl::Texture* texture = new gloost::gl::Texture( g_bufferWidth,
g_bufferHeight,
1,
0,//(unsigned char*)&pixelData->getVector().front(),
16,
GL_TEXTURE_2D,
GL_RGBA16F,
GL_RGBA,
GL_FLOAT);
g_framebufferTextureId = gloost::TextureManager::get()->addTexture(texture);
texture->setTexParameter(GL_TEXTURE_MIN_FILTER, GL_NEAREST);
texture->setTexParameter(GL_TEXTURE_MAG_FILTER, GL_NEAREST);
texture->setTexParameter(GL_TEXTURE_BASE_LEVEL, 0);
texture->setTexParameter(GL_TEXTURE_MAX_LEVEL, 0);
texture->initInContext();
g_camera = new gloost::PerspectiveCamera(65.0,
(float)g_screenWidth/(float)g_screenHeight,
0.01,
20.0);
float xmax = /*g_camera->getNear()**/ tan(g_camera->getFov() * gloost::math::PI / 360.0f) * g_camera->getAspectRatio();
g_tScaleRatio = xmax / /*g_camera->getNear() /*/ (g_bufferWidth*0.5);
std::cerr << std::endl << "g_tScaleRatio: " << g_tScaleRatio;
// float xmax = /*g_camera->getNear()**/ tan(g_eye._camera.getFov() * gloost::PI / 360.0f) * g_eye._camera.getAspect();
// g_tScaleRatio = xmax / /*g_camera->getNear() /*/ (g_bufferWidth*0.5);
// std::cerr << std::endl << "g_tScaleRatio: " << g_tScaleRatio;
// init cl stuff
initCl();
g_clMemoryManager = new svo::TreeletMemoryManagerCl(svo_dir_path + g_svoBaseName,
incoreBufferSizeInByte,
g_context);
// creates the incore ClBuffer
g_clMemoryManager->initClBuffer();
// assign incore buffer to kernel argument
g_context->setKernelArgBuffer("renderToBuffer", 1, g_clMemoryManager->getClIncoreBufferGid());
g_context->setKernelArgBuffer("renderToBuffer", 2, g_clMemoryManager->getClAttributeIncoreBufferGid());
// analyse pass init
g_renderPassAnalyse = new svo::RenderPassAnalyse(g_clMemoryManager,
g_bufferWidth/g_fbToAnalyseBufferDivide,
g_bufferHeight/g_fbToAnalyseBufferDivide);
gloostTest::TimerLog::get()->setNumSamples(10);
}
