GOSTSec
/
sgminer
mirror of https://github.com/GOSTSec/sgminer
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

GPUs cannot be hotplugged

djm34
Jan Berdajs 11 years ago
parent
7f0451336b
commit
7507790880
3 changed files with 147 additions and 148 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      driver-opencl.c
  2. 4
      miner.h
  3. 279
      sgminer.c

12
driver-opencl.c
Unescape View File

@ -268,7 +268,7 @@ char *set_gpu_engine(const char *_arg)
if(!(nextptr = strtok(arg, ","))) if(!(nextptr = strtok(arg, ",")))
return "Invalid parameters for set gpu engine"; return "Invalid parameters for set gpu engine";
do { do {
get_intrange(nextptr, &val1, &val2); get_intrange(nextptr, &val1, &val2);
if (val1 < 0 || val1 > 9999 || val2 < 0 || val2 > 9999) if (val1 < 0 || val1 > 9999 || val2 < 0 || val2 > 9999)
@ -276,12 +276,12 @@ char *set_gpu_engine(const char *_arg)
gpus[device].min_engine = val1; gpus[device].min_engine = val1;
gpus[device].gpu_engine = val2; gpus[device].gpu_engine = val2;
//also set adl settings otherwise range will never properly be applied //also set adl settings otherwise range will never properly be applied
//since min_engine/gpu_engine are only called during init_adl() at startup //since min_engine/gpu_engine are only called during init_adl() at startup
gpus[device].adl.minspeed = val1 * 100; gpus[device].adl.minspeed = val1 * 100;
gpus[device].adl.maxspeed = val2 * 100; gpus[device].adl.maxspeed = val2 * 100;
device++; device++;
} while ((nextptr = strtok(NULL, ",")) != NULL); } while ((nextptr = strtok(NULL, ",")) != NULL);
@ -290,7 +290,7 @@ char *set_gpu_engine(const char *_arg)
for (i = 1; i < MAX_GPUDEVICES; i++) { for (i = 1; i < MAX_GPUDEVICES; i++) {
gpus[i].min_engine = gpus[0].min_engine; gpus[i].min_engine = gpus[0].min_engine;
gpus[i].gpu_engine = gpus[0].gpu_engine; gpus[i].gpu_engine = gpus[0].gpu_engine;
//set adl values //set adl values
gpus[i].adl.minspeed = val1 * 100; gpus[i].adl.minspeed = val1 * 100;
gpus[i].adl.maxspeed = val2 * 100; gpus[i].adl.maxspeed = val2 * 100;
@ -668,7 +668,7 @@ char *set_rawintensity(const char *_arg)
void print_ndevs(int *ndevs) void print_ndevs(int *ndevs)
{ {
opt_log_output = true; opt_log_output = true;
opencl_drv.drv_detect(false); opencl_drv.drv_detect();
clear_adl(*ndevs); clear_adl(*ndevs);
applog(LOG_INFO, "%i GPU devices max detected", *ndevs); applog(LOG_INFO, "%i GPU devices max detected", *ndevs);
} }
@ -1129,7 +1129,7 @@ out:
return NULL; return NULL;
} }
static void opencl_detect(bool hotplug) static void opencl_detect(void)
{ {
int i; int i;

4
miner.h
Unescape View File

@ -358,7 +358,7 @@ enum switcher_options {
SWITCHER_APPLY_GPU_POWERTUNE = 0x4000, SWITCHER_APPLY_GPU_POWERTUNE = 0x4000,
SWITCHER_APPLY_GPU_VDDC = 0x8000, SWITCHER_APPLY_GPU_VDDC = 0x8000,
SWITCHER_SOFT_RESET = 0x4000000, SWITCHER_SOFT_RESET = 0x4000000,
SWITCHER_HARD_RESET = 0x8000000 SWITCHER_HARD_RESET = 0x8000000
}; };
enum gpu_adl_options { enum gpu_adl_options {
@ -382,7 +382,7 @@ struct device_drv {
char *name; char *name;
// DRV-global functions // DRV-global functions
void (*drv_detect)(bool); void (*drv_detect)(void);
// Device-specific functions // Device-specific functions
void (*reinit_device)(struct cgpu_info *); void (*reinit_device)(struct cgpu_info *);

279
sgminer.c
Unescape View File

@ -78,14 +78,14 @@ char *curly = ":D";
void thread_fix_push(pthread_t thread_id) void thread_fix_push(pthread_t thread_id)
{ {
struct thread_fix *new_thread; struct thread_fix *new_thread;
if(!(new_thread = (struct thread_fix *)malloc(sizeof(struct thread_fix)))) if(!(new_thread = (struct thread_fix *)malloc(sizeof(struct thread_fix))))
quit(1, "malloc failed in thread_fix_push()"); quit(1, "malloc failed in thread_fix_push()");
//apply settings //apply settings
new_thread->thread_id = thread_id; new_thread->thread_id = thread_id;
new_thread->prev = new_thread->next = NULL; new_thread->prev = new_thread->next = NULL;
//empty list add to head and tail //empty list add to head and tail
if(!thread_fix_list) if(!thread_fix_list)
{ {
@ -98,36 +98,36 @@ char *curly = ":D";
new_thread->prev = thread_fix_last; new_thread->prev = thread_fix_last;
thread_fix_last = new_thread; thread_fix_last = new_thread;
} }
applog(LOG_DEBUG, "thread_fix_push(%d)", new_thread->thread_id); applog(LOG_DEBUG, "thread_fix_push(%d)", new_thread->thread_id);
} }
static struct thread_fix *thread_fix_search(pthread_t thread_id) static struct thread_fix *thread_fix_search(pthread_t thread_id)
{ {
struct thread_fix *p; struct thread_fix *p;
if(!thread_fix_list) if(!thread_fix_list)
return NULL; return NULL;
p = thread_fix_list; p = thread_fix_list;
while(p != NULL) while(p != NULL)
{ {
if(pthread_equal(p->thread_id, thread_id)) if(pthread_equal(p->thread_id, thread_id))
return p; return p;
p = p->next; p = p->next;
} }
return NULL; return NULL;
} }
void thread_fix_pop(pthread_t thread_id) void thread_fix_pop(pthread_t thread_id)
{ {
struct thread_fix *p; struct thread_fix *p;
if(!(p = thread_fix_search(thread_id))) if(!(p = thread_fix_search(thread_id)))
return; return;
//only 1 item //only 1 item
if((p == thread_fix_list) && (p == thread_fix_last)) if((p == thread_fix_list) && (p == thread_fix_last))
{ {
@ -154,7 +154,7 @@ char *curly = ":D";
} }
applog(LOG_DEBUG, "thread_fix_pop(%d)", p->thread_id); applog(LOG_DEBUG, "thread_fix_pop(%d)", p->thread_id);
//free memory //free memory
free(p); free(p);
} }
@ -731,10 +731,10 @@ char *set_devices(char *arg)
{ {
int i, val1 = 0, val2 = 0; int i, val1 = 0, val2 = 0;
char *p, *nextptr; char *p, *nextptr;
if(arg[0] != '\0') if(arg[0] != '\0')
{ {
if(!strcasecmp(arg, "?")) if(!strcasecmp(arg, "?"))
{ {
opt_display_devs = true; opt_display_devs = true;
return NULL; return NULL;
@ -746,7 +746,7 @@ char *set_devices(char *arg)
opt_devs_enabled = 0; opt_devs_enabled = 0;
return NULL; return NULL;
} }
} }
else else
return "Invalid device parameters"; return "Invalid device parameters";
@ -754,22 +754,22 @@ char *set_devices(char *arg)
p = strdup(arg); p = strdup(arg);
nextptr = strtok(p, ","); nextptr = strtok(p, ",");
do { do {
if (nextptr == NULL) if (nextptr == NULL)
{ {
free(p); free(p);
return "Invalid parameters for set devices"; return "Invalid parameters for set devices";
} }
get_intrange(nextptr, &val1, &val2); get_intrange(nextptr, &val1, &val2);
if (val1 < 0 || val1 > MAX_DEVICES || val2 < 0 || val2 > MAX_DEVICES || val1 > val2) if (val1 < 0 || val1 > MAX_DEVICES || val2 < 0 || val2 > MAX_DEVICES || val1 > val2)
{ {
free(p); free(p);
return "Invalid value passed to set devices"; return "Invalid value passed to set devices";
} }
for (i = val1; i <= val2; i++) for (i = val1; i <= val2; i++)
{ {
devices_enabled[i] = true; devices_enabled[i] = true;
opt_devs_enabled++; opt_devs_enabled++;
@ -777,7 +777,7 @@ char *set_devices(char *arg)
} while ((nextptr = strtok(NULL, ",")) != NULL); } while ((nextptr = strtok(NULL, ",")) != NULL);
applog(LOG_DEBUG, "set_devices(%s) done.", arg); applog(LOG_DEBUG, "set_devices(%s) done.", arg);
free(p); free(p);
return NULL; return NULL;
} }
@ -1078,13 +1078,13 @@ static char *set_switcher_mode(char *arg)
{ {
if(!strcasecmp(arg, "off")) if(!strcasecmp(arg, "off"))
opt_switchmode = SWITCH_OFF; opt_switchmode = SWITCH_OFF;
else if(!strcasecmp(arg, "algorithm")) else if(!strcasecmp(arg, "algorithm"))
opt_switchmode = SWITCH_ALGO; opt_switchmode = SWITCH_ALGO;
else if(!strcasecmp(arg, "pool")) else if(!strcasecmp(arg, "pool"))
opt_switchmode = SWITCH_POOL; opt_switchmode = SWITCH_POOL;
else else
return NULL; return NULL;
applog(LOG_INFO, "Setting switcher mode to %s", arg); applog(LOG_INFO, "Setting switcher mode to %s", arg);
return NULL; return NULL;
} }
@ -1439,7 +1439,7 @@ struct opt_table opt_config_table[] = {
set_gpu_map, NULL, NULL, set_gpu_map, NULL, NULL,
"Map OpenCL to ADL device order manually, paired CSV (e.g. 1:0,2:1 maps OpenCL 1 to ADL 0, 2 to 1)"), "Map OpenCL to ADL device order manually, paired CSV (e.g. 1:0,2:1 maps OpenCL 1 to ADL 0, 2 to 1)"),
OPT_WITH_ARG("--gpu-memclock", OPT_WITH_ARG("--gpu-memclock",
set_default_gpu_memclock, NULL, NULL, set_default_gpu_memclock, NULL, NULL,
"Set the GPU memory (over)clock in Mhz - one value for all or separate by commas for per card"), "Set the GPU memory (over)clock in Mhz - one value for all or separate by commas for per card"),
OPT_WITH_ARG("--gpu-memdiff", OPT_WITH_ARG("--gpu-memdiff",
set_gpu_memdiff, NULL, NULL, set_gpu_memdiff, NULL, NULL,
@ -1474,15 +1474,15 @@ struct opt_table opt_config_table[] = {
" -> " MAX_INTENSITY_STR " -> " MAX_INTENSITY_STR
",default: d to maintain desktop interactivity), overridden by --xintensity or --rawintensity."), ",default: d to maintain desktop interactivity), overridden by --xintensity or --rawintensity."),
OPT_WITH_ARG("--xintensity|-X", OPT_WITH_ARG("--xintensity|-X",
set_default_xintensity, NULL, NULL, set_default_xintensity, NULL, NULL,
"Shader based intensity of GPU scanning (" MIN_XINTENSITY_STR " to " "Shader based intensity of GPU scanning (" MIN_XINTENSITY_STR " to "
MAX_XINTENSITY_STR "), overridden --xintensity|-X and --rawintensity."), MAX_XINTENSITY_STR "), overridden --xintensity|-X and --rawintensity."),
OPT_WITH_ARG("--xintensity|-X", OPT_WITH_ARG("--xintensity|-X",
set_default_xintensity, NULL, NULL, set_default_xintensity, NULL, NULL,
"Shader based intensity of GPU scanning (" MIN_XINTENSITY_STR " to " "Shader based intensity of GPU scanning (" MIN_XINTENSITY_STR " to "
MAX_XINTENSITY_STR "), overrides --intensity|-I, overridden by --rawintensity."), MAX_XINTENSITY_STR "), overrides --intensity|-I, overridden by --rawintensity."),
OPT_WITH_ARG("--rawintensity", OPT_WITH_ARG("--rawintensity",
set_default_rawintensity, NULL, NULL, set_default_rawintensity, NULL, NULL,
"Raw intensity of GPU scanning (" MIN_RAWINTENSITY_STR " to " "Raw intensity of GPU scanning (" MIN_RAWINTENSITY_STR " to "
MAX_RAWINTENSITY_STR "), overrides --intensity|-I and --xintensity|-X."), MAX_RAWINTENSITY_STR "), overrides --intensity|-I and --xintensity|-X."),
OPT_WITH_ARG("--kernel-path|-K", OPT_WITH_ARG("--kernel-path|-K",
@ -1543,7 +1543,7 @@ struct opt_table opt_config_table[] = {
OPT_WITHOUT_ARG("--per-device-stats", OPT_WITHOUT_ARG("--per-device-stats",
opt_set_bool, &want_per_device_stats, opt_set_bool, &want_per_device_stats,
"Force verbose mode and output per-device statistics"), "Force verbose mode and output per-device statistics"),
OPT_WITH_ARG("--poolname", /* TODO: Backward compatibility, to be removed. */ OPT_WITH_ARG("--poolname", /* TODO: Backward compatibility, to be removed. */
set_poolname_deprecated, NULL, NULL, set_poolname_deprecated, NULL, NULL,
opt_hidden), opt_hidden),
@ -1581,7 +1581,7 @@ struct opt_table opt_config_table[] = {
"Intensity of GPU scanning (pool-specific)"), "Intensity of GPU scanning (pool-specific)"),
OPT_WITH_ARG("--pool-nfactor", OPT_WITH_ARG("--pool-nfactor",
set_pool_nfactor, NULL, NULL, set_pool_nfactor, NULL, NULL,
"Set N-factor for pool"), "Set N-factor for pool"),
OPT_WITH_ARG("--pool-profile", OPT_WITH_ARG("--pool-profile",
set_pool_profile, NULL, NULL, set_pool_profile, NULL, NULL,
"Profile to use with the pool"), "Profile to use with the pool"),
@ -1600,11 +1600,11 @@ struct opt_table opt_config_table[] = {
OPT_WITH_ARG("--pool-xintensity", OPT_WITH_ARG("--pool-xintensity",
set_pool_xintensity, NULL, NULL, set_pool_xintensity, NULL, NULL,
"Shader based intensity of GPU scanning (pool-specific)"), "Shader based intensity of GPU scanning (pool-specific)"),
OPT_WITH_ARG("--priority|--pool-priority", OPT_WITH_ARG("--priority|--pool-priority",
set_pool_priority, NULL, NULL, set_pool_priority, NULL, NULL,
"Pool priority"), "Pool priority"),
OPT_WITH_ARG("--profile-algorithm|--profile-kernel", OPT_WITH_ARG("--profile-algorithm|--profile-kernel",
set_profile_algorithm, NULL, NULL, set_profile_algorithm, NULL, NULL,
"Set algorithm for profile"), "Set algorithm for profile"),
@ -1658,7 +1658,7 @@ struct opt_table opt_config_table[] = {
OPT_WITH_ARG("--profile-xintensity", OPT_WITH_ARG("--profile-xintensity",
set_profile_xintensity, NULL, NULL, set_profile_xintensity, NULL, NULL,
"Shader based intensity of GPU scanning (profile-specific)"), "Shader based intensity of GPU scanning (profile-specific)"),
OPT_WITHOUT_ARG("--protocol-dump|-P", OPT_WITHOUT_ARG("--protocol-dump|-P",
opt_set_bool, &opt_protocol, opt_set_bool, &opt_protocol,
"Verbose dump of protocol-level activities"), "Verbose dump of protocol-level activities"),
@ -1757,7 +1757,7 @@ struct opt_table opt_config_table[] = {
opt_hidden), opt_hidden),
#endif #endif
OPT_WITH_ARG("--thread-concurrency", OPT_WITH_ARG("--thread-concurrency",
set_default_thread_concurrency, NULL, NULL, set_default_thread_concurrency, NULL, NULL,
"Set GPU thread concurrency for scrypt mining, comma separated"), "Set GPU thread concurrency for scrypt mining, comma separated"),
OPT_WITH_ARG("--url|--pool-url|-o", OPT_WITH_ARG("--url|--pool-url|-o",
set_url, NULL, NULL, set_url, NULL, NULL,
@ -2231,7 +2231,7 @@ static bool work_decode(struct pool *pool, struct work *work, json_t *val)
} }
work->pool = pool; work->pool = pool;
if (pool->has_gbt) { if (pool->has_gbt) {
if (unlikely(!gbt_decode(pool, res_val))) if (unlikely(!gbt_decode(pool, res_val)))
goto out; goto out;
@ -2848,11 +2848,11 @@ share_result(json_t *val, json_t *res, json_t *err, const struct work *work,
} }
applog(LOG_NOTICE, "Rejected %s %s %d %s%s %s%s", applog(LOG_NOTICE, "Rejected %s %s %d %s%s %s%s",
hashshow, hashshow,
cgpu->drv->name, cgpu->drv->name,
cgpu->device_id, cgpu->device_id,
(total_pools > 1) ? get_pool_name(pool) : "", (total_pools > 1) ? get_pool_name(pool) : "",
reason, resubmit ? "(resubmit)" : "", reason, resubmit ? "(resubmit)" : "",
worktime); worktime);
sharelog(disposition, work); sharelog(disposition, work);
} }
@ -3981,11 +3981,11 @@ void switch_pools(struct pool *selected)
pool_no = currentpool->pool_no; pool_no = currentpool->pool_no;
/* If a specific pool was selected, prioritise it over others */ /* If a specific pool was selected, prioritise it over others */
if (selected) if (selected)
{ {
if (selected->prio != 0) if (selected->prio != 0)
{ {
for (i = 0; i < total_pools; i++) for (i = 0; i < total_pools; i++)
{ {
pool = pools[i]; pool = pools[i];
if (pool->prio < selected->prio) if (pool->prio < selected->prio)
@ -3995,13 +3995,13 @@ void switch_pools(struct pool *selected)
} }
} }
switch (pool_strategy) switch (pool_strategy)
{ {
/* All of these set to the master pool */ /* All of these set to the master pool */
case POOL_BALANCE: case POOL_BALANCE:
case POOL_FAILOVER: case POOL_FAILOVER:
case POOL_LOADBALANCE: case POOL_LOADBALANCE:
for (i = 0; i < total_pools; i++) for (i = 0; i < total_pools; i++)
{ {
pool = priority_pool(i); pool = priority_pool(i);
if (pool_unusable(pool)) if (pool_unusable(pool))
@ -4013,27 +4013,27 @@ void switch_pools(struct pool *selected)
/* Both of these simply increment and cycle */ /* Both of these simply increment and cycle */
case POOL_ROUNDROBIN: case POOL_ROUNDROBIN:
case POOL_ROTATE: case POOL_ROTATE:
if (selected && !selected->idle) if (selected && !selected->idle)
{ {
pool_no = selected->pool_no; pool_no = selected->pool_no;
break; break;
} }
next_pool = pool_no; next_pool = pool_no;
/* Select the next alive pool */ /* Select the next alive pool */
for (i = 1; i < total_pools; i++) for (i = 1; i < total_pools; i++)
{ {
next_pool++; next_pool++;
if (next_pool >= total_pools) if (next_pool >= total_pools)
next_pool = 0; next_pool = 0;
pool = pools[next_pool]; pool = pools[next_pool];
if (pool_unusable(pool)) if (pool_unusable(pool))
continue; continue;
pool_no = next_pool; pool_no = next_pool;
break; break;
} }
@ -4052,7 +4052,7 @@ void switch_pools(struct pool *selected)
if (opt_fail_only) if (opt_fail_only)
pool_tset(pool, &pool->lagging); pool_tset(pool, &pool->lagging);
if (pool != last_pool && pool_strategy != POOL_LOADBALANCE && pool_strategy != POOL_BALANCE) if (pool != last_pool && pool_strategy != POOL_LOADBALANCE && pool_strategy != POOL_BALANCE)
{ {
//if the gpus have been initialized or first pool during startup, it's ok to switch... //if the gpus have been initialized or first pool during startup, it's ok to switch...
if(gpu_initialized || startup) if(gpu_initialized || startup)
@ -4062,19 +4062,19 @@ void switch_pools(struct pool *selected)
clear_pool_work(last_pool); clear_pool_work(last_pool);
} }
} }
//if startup, initialize gpus and start mining threads //if startup, initialize gpus and start mining threads
if(startup) if(startup)
{ {
startup = false; //remove startup flag so we don't enter this block again startup = false; //remove startup flag so we don't enter this block again
applog(LOG_NOTICE, "Startup GPU initialization... Using settings from pool %s.", get_pool_name(pool)); applog(LOG_NOTICE, "Startup GPU initialization... Using settings from pool %s.", get_pool_name(pool));
//set initial pool number for restart_mining_threads to prevent mismatched GPU settings //set initial pool number for restart_mining_threads to prevent mismatched GPU settings
init_pool = pool->pool_no; init_pool = pool->pool_no;
//apply gpu settings based on first alive pool //apply gpu settings based on first alive pool
apply_initial_gpu_settings(pool); apply_initial_gpu_settings(pool);
gpu_initialized = true; //gpus initialized gpu_initialized = true; //gpus initialized
} }
@ -6016,9 +6016,9 @@ static void apply_initial_gpu_settings(struct pool *pool)
const char *opt; const char *opt;
unsigned char options; //gpu adl options to apply unsigned char options; //gpu adl options to apply
unsigned int needed_threads = 0; //number of mining threads needed after we change devices unsigned int needed_threads = 0; //number of mining threads needed after we change devices
applog(LOG_NOTICE, "Startup Pool No = %d", pool->pool_no); applog(LOG_NOTICE, "Startup Pool No = %d", pool->pool_no);
//apply gpu settings //apply gpu settings
rd_lock(&mining_thr_lock); rd_lock(&mining_thr_lock);
@ -6026,11 +6026,11 @@ static void apply_initial_gpu_settings(struct pool *pool)
opt_devs_enabled = 0; opt_devs_enabled = 0;
for (i = 0; i < MAX_DEVICES; i++) for (i = 0; i < MAX_DEVICES; i++)
devices_enabled[i] = false; devices_enabled[i] = false;
//assign pool devices if any //assign pool devices if any
if(!empty_string((opt = get_pool_setting(pool->devices, ((!empty_string(default_profile.devices))?default_profile.devices:"all"))))) if(!empty_string((opt = get_pool_setting(pool->devices, ((!empty_string(default_profile.devices))?default_profile.devices:"all")))))
set_devices((char *)opt); set_devices((char *)opt);
//lookup gap //lookup gap
if(!empty_string((opt = get_pool_setting(pool->lookup_gap, default_profile.lookup_gap)))) if(!empty_string((opt = get_pool_setting(pool->lookup_gap, default_profile.lookup_gap))))
set_lookup_gap((char *)opt); set_lookup_gap((char *)opt);
@ -6050,7 +6050,7 @@ static void apply_initial_gpu_settings(struct pool *pool)
//thread-concurrency //thread-concurrency
if(!empty_string((opt = get_pool_setting(pool->thread_concurrency, default_profile.thread_concurrency)))) if(!empty_string((opt = get_pool_setting(pool->thread_concurrency, default_profile.thread_concurrency))))
set_thread_concurrency((char *)opt); set_thread_concurrency((char *)opt);
//worksize //worksize
if(!empty_string((opt = get_pool_setting(pool->worksize, default_profile.worksize)))) if(!empty_string((opt = get_pool_setting(pool->worksize, default_profile.worksize))))
set_worksize((char *)opt); set_worksize((char *)opt);
@ -6061,16 +6061,16 @@ static void apply_initial_gpu_settings(struct pool *pool)
applog(LOG_DEBUG, "Set GPU %d to %s", i, isnull(pool->algorithm.name, "")); applog(LOG_DEBUG, "Set GPU %d to %s", i, isnull(pool->algorithm.name, ""));
gpus[i].algorithm = pool->algorithm; gpus[i].algorithm = pool->algorithm;
} }
#ifdef HAVE_ADL #ifdef HAVE_ADL
options = APPLY_ENGINE | APPLY_MEMCLOCK | APPLY_FANSPEED | APPLY_POWERTUNE | APPLY_VDDC; options = APPLY_ENGINE | APPLY_MEMCLOCK | APPLY_FANSPEED | APPLY_POWERTUNE | APPLY_VDDC;
//GPU clock //GPU clock
if(!empty_string((opt = get_pool_setting(pool->gpu_engine, default_profile.gpu_engine)))) if(!empty_string((opt = get_pool_setting(pool->gpu_engine, default_profile.gpu_engine))))
set_gpu_engine((char *)opt); set_gpu_engine((char *)opt);
else else
options ^= APPLY_ENGINE; options ^= APPLY_ENGINE;
//GPU memory clock //GPU memory clock
if(!empty_string((opt = get_pool_setting(pool->gpu_memclock, default_profile.gpu_memclock)))) if(!empty_string((opt = get_pool_setting(pool->gpu_memclock, default_profile.gpu_memclock))))
set_gpu_memclock((char *)opt); set_gpu_memclock((char *)opt);
@ -6088,13 +6088,13 @@ static void apply_initial_gpu_settings(struct pool *pool)
set_gpu_powertune((char *)opt); set_gpu_powertune((char *)opt);
else else
options ^= APPLY_POWERTUNE; options ^= APPLY_POWERTUNE;
//GPU vddc //GPU vddc
if(!empty_string((opt = get_pool_setting(pool->gpu_vddc, default_profile.gpu_vddc)))) if(!empty_string((opt = get_pool_setting(pool->gpu_vddc, default_profile.gpu_vddc))))
set_gpu_vddc((char *)opt); set_gpu_vddc((char *)opt);
else else
options ^= APPLY_VDDC; options ^= APPLY_VDDC;
//apply gpu settings //apply gpu settings
for (i = 0; i < nDevs; i++) for (i = 0; i < nDevs; i++)
{ {
@ -6112,10 +6112,10 @@ static void apply_initial_gpu_settings(struct pool *pool)
#endif #endif
rd_unlock(&mining_thr_lock); rd_unlock(&mining_thr_lock);
//enable/disable devices as needed //enable/disable devices as needed
enable_devices(); enable_devices();
//recount the number of needed mining threads //recount the number of needed mining threads
#ifdef HAVE_ADL #ifdef HAVE_ADL
if(!empty_string((opt = get_pool_setting(pool->gpu_threads, default_profile.gpu_threads)))) if(!empty_string((opt = get_pool_setting(pool->gpu_threads, default_profile.gpu_threads))))
@ -6131,7 +6131,7 @@ static void apply_initial_gpu_settings(struct pool *pool)
//bad thread count? //bad thread count?
if(needed_threads == 0) if(needed_threads == 0)
quit(1, "No GPUs Initialized."); quit(1, "No GPUs Initialized.");
restart_mining_threads(needed_threads); restart_mining_threads(needed_threads);
} }
@ -6139,10 +6139,10 @@ static unsigned long compare_pool_settings(struct pool *pool1, struct pool *pool
{ {
unsigned int options = 0; unsigned int options = 0;
const char *opt1, *opt2; const char *opt1, *opt2;
if(!pool1 || !pool2) if(!pool1 || !pool2)
return 0; return 0;
//compare algorithm //compare algorithm
if(!cmp_algorithm(&pool1->algorithm, &pool2->algorithm)) if(!cmp_algorithm(&pool1->algorithm, &pool2->algorithm))
options |= (SWITCHER_APPLY_ALGO | SWITCHER_HARD_RESET); options |= (SWITCHER_APPLY_ALGO | SWITCHER_HARD_RESET);
@ -6150,44 +6150,44 @@ static unsigned long compare_pool_settings(struct pool *pool1, struct pool *pool
//compare pool devices //compare pool devices
opt1 = get_pool_setting(pool1->devices, ((!empty_string(default_profile.devices))?default_profile.devices:"all")); opt1 = get_pool_setting(pool1->devices, ((!empty_string(default_profile.devices))?default_profile.devices:"all"));
opt2 = get_pool_setting(pool2->devices, ((!empty_string(default_profile.devices))?default_profile.devices:"all")); opt2 = get_pool_setting(pool2->devices, ((!empty_string(default_profile.devices))?default_profile.devices:"all"));
//changing devices means a hard reset of mining threads //changing devices means a hard reset of mining threads
if(strcasecmp(opt1, opt2) != 0) if(strcasecmp(opt1, opt2) != 0)
options |= (SWITCHER_APPLY_DEVICE | SWITCHER_HARD_RESET); options |= (SWITCHER_APPLY_DEVICE | SWITCHER_HARD_RESET);
//compare gpu threads //compare gpu threads
opt1 = get_pool_setting(pool1->gpu_threads, default_profile.gpu_threads); opt1 = get_pool_setting(pool1->gpu_threads, default_profile.gpu_threads);
opt2 = get_pool_setting(pool2->gpu_threads, default_profile.gpu_threads); opt2 = get_pool_setting(pool2->gpu_threads, default_profile.gpu_threads);
//changing gpu threads means a hard reset of mining threads //changing gpu threads means a hard reset of mining threads
if(strcasecmp(opt1, opt2) != 0) if(strcasecmp(opt1, opt2) != 0)
options |= (SWITCHER_APPLY_GT | SWITCHER_HARD_RESET); options |= (SWITCHER_APPLY_GT | SWITCHER_HARD_RESET);
//lookup gap //lookup gap
opt1 = get_pool_setting(pool1->lookup_gap, default_profile.lookup_gap); opt1 = get_pool_setting(pool1->lookup_gap, default_profile.lookup_gap);
opt2 = get_pool_setting(pool2->lookup_gap, default_profile.lookup_gap); opt2 = get_pool_setting(pool2->lookup_gap, default_profile.lookup_gap);
//lookup gap means soft reset but only if hard reset isnt set //lookup gap means soft reset but only if hard reset isnt set
if(strcasecmp(opt1, opt2) != 0) if(strcasecmp(opt1, opt2) != 0)
options |= (SWITCHER_APPLY_LG | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0)); options |= (SWITCHER_APPLY_LG | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0));
//intensities //intensities
opt1 = get_pool_setting(pool1->rawintensity, default_profile.rawintensity); opt1 = get_pool_setting(pool1->rawintensity, default_profile.rawintensity);
opt2 = get_pool_setting(pool2->rawintensity, default_profile.rawintensity); opt2 = get_pool_setting(pool2->rawintensity, default_profile.rawintensity);
if(strcasecmp(opt1, opt2) != 0) if(strcasecmp(opt1, opt2) != 0)
{ {
//intensity is soft reset //intensity is soft reset
if(!empty_string(opt2)) if(!empty_string(opt2))
options |= (SWITCHER_APPLY_RAWINT | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0)); options |= (SWITCHER_APPLY_RAWINT | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0));
} }
//xintensity -- only if raw intensity not set //xintensity -- only if raw intensity not set
if(!opt_isset(options, SWITCHER_APPLY_RAWINT)) if(!opt_isset(options, SWITCHER_APPLY_RAWINT))
{ {
opt1 = get_pool_setting(pool1->xintensity, default_profile.xintensity); opt1 = get_pool_setting(pool1->xintensity, default_profile.xintensity);
opt2 = get_pool_setting(pool2->xintensity, default_profile.xintensity); opt2 = get_pool_setting(pool2->xintensity, default_profile.xintensity);
//if different... //if different...
if(strcasecmp(opt1, opt2) != 0) if(strcasecmp(opt1, opt2) != 0)
{ {
@ -6196,13 +6196,13 @@ static unsigned long compare_pool_settings(struct pool *pool1, struct pool *pool
options |= (SWITCHER_APPLY_XINT | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0)); options |= (SWITCHER_APPLY_XINT | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0));
} }
} }
//intensity -- only if raw intensity and xintensity not set //intensity -- only if raw intensity and xintensity not set
if(!opt_isset(options, SWITCHER_APPLY_RAWINT) && !opt_isset(options, SWITCHER_APPLY_XINT)) if(!opt_isset(options, SWITCHER_APPLY_RAWINT) && !opt_isset(options, SWITCHER_APPLY_XINT))
{ {
opt1 = get_pool_setting(pool1->intensity, default_profile.intensity); opt1 = get_pool_setting(pool1->intensity, default_profile.intensity);
opt2 = get_pool_setting(pool2->intensity, default_profile.intensity); opt2 = get_pool_setting(pool2->intensity, default_profile.intensity);
//if different... //if different...
if(strcasecmp(opt1, opt2) != 0) if(strcasecmp(opt1, opt2) != 0)
{ {
@ -6214,11 +6214,11 @@ static unsigned long compare_pool_settings(struct pool *pool1, struct pool *pool
options |= (SWITCHER_APPLY_INT8 | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0)); options |= (SWITCHER_APPLY_INT8 | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0));
} }
} }
//shaders //shaders
opt1 = get_pool_setting(pool1->shaders, default_profile.shaders); opt1 = get_pool_setting(pool1->shaders, default_profile.shaders);
opt2 = get_pool_setting(pool2->shaders, default_profile.shaders); opt2 = get_pool_setting(pool2->shaders, default_profile.shaders);
if(strcasecmp(opt1, opt2) != 0) if(strcasecmp(opt1, opt2) != 0)
{ {
//shaders is soft reset //shaders is soft reset
@ -6229,7 +6229,7 @@ static unsigned long compare_pool_settings(struct pool *pool1, struct pool *pool
//thread-concurrency //thread-concurrency
opt1 = get_pool_setting(pool1->thread_concurrency, default_profile.thread_concurrency); opt1 = get_pool_setting(pool1->thread_concurrency, default_profile.thread_concurrency);
opt2 = get_pool_setting(pool2->thread_concurrency, default_profile.thread_concurrency); opt2 = get_pool_setting(pool2->thread_concurrency, default_profile.thread_concurrency);
//thread-concurrency is soft reset //thread-concurrency is soft reset
if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2)) if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2))
options |= (SWITCHER_APPLY_TC | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0)); options |= (SWITCHER_APPLY_TC | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0));
@ -6237,7 +6237,7 @@ static unsigned long compare_pool_settings(struct pool *pool1, struct pool *pool
//worksize //worksize
opt1 = get_pool_setting(pool1->worksize, default_profile.worksize); opt1 = get_pool_setting(pool1->worksize, default_profile.worksize);
opt2 = get_pool_setting(pool2->worksize, default_profile.worksize); opt2 = get_pool_setting(pool2->worksize, default_profile.worksize);
//worksize is soft reset //worksize is soft reset
if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2)) if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2))
options |= (SWITCHER_APPLY_WORKSIZE | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0)); options |= (SWITCHER_APPLY_WORKSIZE | ((!opt_isset(options, SWITCHER_HARD_RESET))?SWITCHER_SOFT_RESET:0));
@ -6246,35 +6246,35 @@ static unsigned long compare_pool_settings(struct pool *pool1, struct pool *pool
//gpu-engine //gpu-engine
opt1 = get_pool_setting(pool1->gpu_engine, default_profile.gpu_engine); opt1 = get_pool_setting(pool1->gpu_engine, default_profile.gpu_engine);
opt2 = get_pool_setting(pool2->gpu_engine, default_profile.gpu_engine); opt2 = get_pool_setting(pool2->gpu_engine, default_profile.gpu_engine);
if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2)) if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2))
options |= SWITCHER_APPLY_GPU_ENGINE; options |= SWITCHER_APPLY_GPU_ENGINE;
//gpu-memclock //gpu-memclock
opt1 = get_pool_setting(pool1->gpu_memclock, default_profile.gpu_memclock); opt1 = get_pool_setting(pool1->gpu_memclock, default_profile.gpu_memclock);
opt2 = get_pool_setting(pool2->gpu_memclock, default_profile.gpu_memclock); opt2 = get_pool_setting(pool2->gpu_memclock, default_profile.gpu_memclock);
if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2)) if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2))
options |= SWITCHER_APPLY_GPU_MEMCLOCK; options |= SWITCHER_APPLY_GPU_MEMCLOCK;
//GPU fans //GPU fans
opt1 = get_pool_setting(pool1->gpu_fan, default_profile.gpu_fan); opt1 = get_pool_setting(pool1->gpu_fan, default_profile.gpu_fan);
opt2 = get_pool_setting(pool2->gpu_fan, default_profile.gpu_fan); opt2 = get_pool_setting(pool2->gpu_fan, default_profile.gpu_fan);
if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2)) if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2))
options |= SWITCHER_APPLY_GPU_FAN; options |= SWITCHER_APPLY_GPU_FAN;
//GPU powertune //GPU powertune
opt1 = get_pool_setting(pool1->gpu_powertune, default_profile.gpu_powertune); opt1 = get_pool_setting(pool1->gpu_powertune, default_profile.gpu_powertune);
opt2 = get_pool_setting(pool2->gpu_powertune, default_profile.gpu_powertune); opt2 = get_pool_setting(pool2->gpu_powertune, default_profile.gpu_powertune);
if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2)) if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2))
options |= SWITCHER_APPLY_GPU_POWERTUNE; options |= SWITCHER_APPLY_GPU_POWERTUNE;
//GPU vddc //GPU vddc
opt1 = get_pool_setting(pool1->gpu_vddc, default_profile.gpu_vddc); opt1 = get_pool_setting(pool1->gpu_vddc, default_profile.gpu_vddc);
opt2 = get_pool_setting(pool2->gpu_vddc, default_profile.gpu_vddc); opt2 = get_pool_setting(pool2->gpu_vddc, default_profile.gpu_vddc);
if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2)) if(strcasecmp(opt1, opt2) != 0 && !empty_string(opt2))
options |= SWITCHER_APPLY_GPU_VDDC; options |= SWITCHER_APPLY_GPU_VDDC;
#endif #endif
@ -6316,17 +6316,17 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
return; return;
} }
} }
algo_switch_n++; algo_switch_n++;
//get the number of active threads to know when to switch... if we only check total threads, we may wait for ever on a disabled GPU //get the number of active threads to know when to switch... if we only check total threads, we may wait for ever on a disabled GPU
active_threads = 0; active_threads = 0;
rd_lock(&mining_thr_lock); rd_lock(&mining_thr_lock);
for(i = 0; i < mining_threads; i++) for(i = 0; i < mining_threads; i++)
{ {
struct cgpu_info *cgpu = mining_thr[i]->cgpu; struct cgpu_info *cgpu = mining_thr[i]->cgpu;
//dont count dead/sick GPU threads or we may wait for ever also... //dont count dead/sick GPU threads or we may wait for ever also...
if(cgpu->deven != DEV_DISABLED && cgpu->status != LIFE_SICK && cgpu->status != LIFE_DEAD) if(cgpu->deven != DEV_DISABLED && cgpu->status != LIFE_SICK && cgpu->status != LIFE_DEAD)
active_threads++; active_threads++;
@ -6334,15 +6334,15 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
rd_unlock(&mining_thr_lock); rd_unlock(&mining_thr_lock);
// If all threads are waiting now // If all threads are waiting now
if(algo_switch_n >= active_threads) if(algo_switch_n >= active_threads)
{ {
//compare pools to figure out what we need to apply, if options is 0, don't change anything... //compare pools to figure out what we need to apply, if options is 0, don't change anything...
if((options = compare_pool_settings(pools[mythr->pool_no], work->pool))) if((options = compare_pool_settings(pools[mythr->pool_no], work->pool)))
{ {
rd_lock(&mining_thr_lock); rd_lock(&mining_thr_lock);
// Shutdown all threads first (necessary) // Shutdown all threads first (necessary)
if(opt_isset(options, SWITCHER_SOFT_RESET)) if(opt_isset(options, SWITCHER_SOFT_RESET))
{ {
applog(LOG_DEBUG, "Soft Reset... Shutdown threads..."); applog(LOG_DEBUG, "Soft Reset... Shutdown threads...");
for (i = 0; i < mining_threads; i++) for (i = 0; i < mining_threads; i++)
@ -6351,7 +6351,7 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
thr->cgpu->drv->thread_shutdown(thr); thr->cgpu->drv->thread_shutdown(thr);
} }
} }
// Reset stats (e.g. for working_diff to be set properly in hash_sole_work) // Reset stats (e.g. for working_diff to be set properly in hash_sole_work)
zero_stats(); zero_stats();
@ -6362,19 +6362,19 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
opt_devs_enabled = 0; opt_devs_enabled = 0;
for (i = 0; i < MAX_DEVICES; i++) for (i = 0; i < MAX_DEVICES; i++)
devices_enabled[i] = false; devices_enabled[i] = false;
//assign pool devices if any //assign pool devices if any
if(!empty_string((opt = get_pool_setting(work->pool->devices, ((!empty_string(default_profile.devices))?default_profile.devices:"all"))))) if(!empty_string((opt = get_pool_setting(work->pool->devices, ((!empty_string(default_profile.devices))?default_profile.devices:"all")))))
set_devices((char *)opt); set_devices((char *)opt);
} }
//lookup gap //lookup gap
if(opt_isset(options, SWITCHER_APPLY_LG)) if(opt_isset(options, SWITCHER_APPLY_LG))
{ {
if(!empty_string((opt = get_pool_setting(work->pool->lookup_gap, default_profile.lookup_gap)))) if(!empty_string((opt = get_pool_setting(work->pool->lookup_gap, default_profile.lookup_gap))))
set_lookup_gap((char *)opt); set_lookup_gap((char *)opt);
} }
//raw intensity from pool //raw intensity from pool
if(opt_isset(options, SWITCHER_APPLY_RAWINT)) if(opt_isset(options, SWITCHER_APPLY_RAWINT))
{ {
@ -6399,7 +6399,7 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
default_profile.intensity = strdup("8"); default_profile.intensity = strdup("8");
set_intensity(default_profile.intensity); set_intensity(default_profile.intensity);
} }
//shaders //shaders
if(opt_isset(options, SWITCHER_APPLY_SHADER)) if(opt_isset(options, SWITCHER_APPLY_SHADER))
{ {
@ -6428,7 +6428,7 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
if(!empty_string((opt = get_pool_setting(work->pool->gpu_engine, default_profile.gpu_engine)))) if(!empty_string((opt = get_pool_setting(work->pool->gpu_engine, default_profile.gpu_engine))))
set_gpu_engine((char *)opt); set_gpu_engine((char *)opt);
} }
//GPU memory clock //GPU memory clock
if(opt_isset(options, SWITCHER_APPLY_GPU_MEMCLOCK)) if(opt_isset(options, SWITCHER_APPLY_GPU_MEMCLOCK))
{ {
@ -6476,18 +6476,18 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
// Change algorithm for each thread (thread_prepare calls initCl) // Change algorithm for each thread (thread_prepare calls initCl)
if(opt_isset(options, SWITCHER_SOFT_RESET)) if(opt_isset(options, SWITCHER_SOFT_RESET))
applog(LOG_DEBUG, "Soft Reset... Restarting threads..."); applog(LOG_DEBUG, "Soft Reset... Restarting threads...");
struct thr_info *thr; struct thr_info *thr;
for (i = 0; i < mining_threads; i++) for (i = 0; i < mining_threads; i++)
{ {
thr = mining_thr[i]; thr = mining_thr[i];
thr->pool_no = work->pool->pool_no; //set thread on new pool thr->pool_no = work->pool->pool_no; //set thread on new pool
//apply new algorithm if set //apply new algorithm if set
if(opt_isset(options, SWITCHER_APPLY_ALGO)) if(opt_isset(options, SWITCHER_APPLY_ALGO))
thr->cgpu->algorithm = work->pool->algorithm; thr->cgpu->algorithm = work->pool->algorithm;
if(opt_isset(options, SWITCHER_SOFT_RESET)) if(opt_isset(options, SWITCHER_SOFT_RESET))
{ {
thr->cgpu->drv->thread_prepare(thr); thr->cgpu->drv->thread_prepare(thr);
@ -6497,14 +6497,14 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
// Necessary because algorithms can have dramatically different diffs // Necessary because algorithms can have dramatically different diffs
thr->cgpu->drv->working_diff = 1; thr->cgpu->drv->working_diff = 1;
} }
rd_unlock(&mining_thr_lock); rd_unlock(&mining_thr_lock);
// Finish switching pools // Finish switching pools
algo_switch_n = 0; algo_switch_n = 0;
mutex_unlock(&algo_switch_lock); mutex_unlock(&algo_switch_lock);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
// Hard restart if needed // Hard restart if needed
if(opt_isset(options, SWITCHER_HARD_RESET)) if(opt_isset(options, SWITCHER_HARD_RESET))
{ {
@ -6516,11 +6516,11 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
// reset devices // reset devices
enable_devices(); enable_devices();
} }
//figure out how many mining threads we'll need //figure out how many mining threads we'll need
unsigned int n_threads = 0; unsigned int n_threads = 0;
pthread_t restart_thr; pthread_t restart_thr;
#ifdef HAVE_ADL #ifdef HAVE_ADL
//change gpu threads if needed //change gpu threads if needed
if(opt_isset(options, SWITCHER_APPLY_GT)) if(opt_isset(options, SWITCHER_APPLY_GT))
@ -6528,18 +6528,18 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
if(!empty_string((opt = get_pool_setting(work->pool->gpu_threads, default_profile.gpu_threads)))) if(!empty_string((opt = get_pool_setting(work->pool->gpu_threads, default_profile.gpu_threads))))
set_gpu_threads(opt); set_gpu_threads(opt);
} }
for (i = 0; i < total_devices; i++) for (i = 0; i < total_devices; i++)
if (!opt_removedisabled || !opt_devs_enabled || devices_enabled[i]) if (!opt_removedisabled || !opt_devs_enabled || devices_enabled[i])
n_threads += devices[i]->threads; n_threads += devices[i]->threads;
#else #else
n_threads = mining_threads; n_threads = mining_threads;
#endif #endif
if (unlikely(pthread_create(&restart_thr, NULL, restart_mining_threads_thread, (void *) (intptr_t) n_threads))) if (unlikely(pthread_create(&restart_thr, NULL, restart_mining_threads_thread, (void *) (intptr_t) n_threads)))
quit(1, "restart_mining_threads create thread failed"); quit(1, "restart_mining_threads create thread failed");
sleep(60); sleep(60);
#ifdef __TEMP_ALGO_SWITCH_FIX__ #ifdef __TEMP_ALGO_SWITCH_FIX__
//if restart thread is done, then abort... //if restart thread is done, then abort...
if(!thread_fix_search(restart_thr)) if(!thread_fix_search(restart_thr))
@ -6552,7 +6552,7 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
return; return;
} }
#endif /* __TEMP_ALGO_SWITCH_FIX__ */ #endif /* __TEMP_ALGO_SWITCH_FIX__ */
quit(1, "thread was not cancelled in 60 seconds after restart_mining_threads"); quit(1, "thread was not cancelled in 60 seconds after restart_mining_threads");
} }
} }
@ -6570,14 +6570,14 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
mutex_unlock(&algo_switch_lock); mutex_unlock(&algo_switch_lock);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
} }
// Signal other threads to start working now // Signal other threads to start working now
mutex_lock(&algo_switch_wait_lock); mutex_lock(&algo_switch_wait_lock);
pthread_cond_broadcast(&algo_switch_wait_cond); pthread_cond_broadcast(&algo_switch_wait_cond);
mutex_unlock(&algo_switch_wait_lock); mutex_unlock(&algo_switch_wait_lock);
// Not all threads are waiting, join the waiting list // Not all threads are waiting, join the waiting list
} }
else else
{ {
mutex_unlock(&algo_switch_lock); mutex_unlock(&algo_switch_lock);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
@ -7644,7 +7644,7 @@ static void *test_pool_thread(void *arg)
{ {
struct pool *pool = (struct pool *)arg; struct pool *pool = (struct pool *)arg;
if (pool_active(pool, false)) if (pool_active(pool, false))
{ {
pool_tset(pool, &pool->lagging); pool_tset(pool, &pool->lagging);
pool_tclear(pool, &pool->idle); pool_tclear(pool, &pool->idle);
@ -7685,12 +7685,12 @@ bool add_pool_details(struct pool *pool, bool live, char *url, char *user, char
pool->name = name; pool->name = name;
pool->description = desc; pool->description = desc;
pool->profile = profile; pool->profile = profile;
//if a profile was supplied, apply pool properties from profile //if a profile was supplied, apply pool properties from profile
if(!empty_string(profile)) if(!empty_string(profile))
apply_pool_profile(pool); //remove profile if was invalid apply_pool_profile(pool); //remove profile if was invalid
//if profile is empty, assign algorithm or default algorithm //if profile is empty, assign algorithm or default algorithm
if(empty_string(pool->profile)) if(empty_string(pool->profile))
{ {
if(!empty_string(algo)) if(!empty_string(algo))
@ -7934,7 +7934,7 @@ static void noop_thread_enable(struct thr_info __maybe_unused *thr)
{ {
} }
static void noop_detect(bool __maybe_unused hotplug) static void noop_detect(void)
{ {
} }
#define noop_flush_work noop_reinit_device #define noop_flush_work noop_reinit_device
@ -8039,7 +8039,7 @@ static void probe_pools(void)
{ {
int i; int i;
for (i = 0; i < total_pools; i++) for (i = 0; i < total_pools; i++)
{ {
struct pool *pool = pools[i]; struct pool *pool = pools[i];
@ -8054,7 +8054,7 @@ static void restart_mining_threads(unsigned int new_n_threads)
unsigned int i, j, k; unsigned int i, j, k;
// Stop and free threads // Stop and free threads
if (mining_thr) if (mining_thr)
{ {
rd_lock(&mining_thr_lock); rd_lock(&mining_thr_lock);
for (i = 0; i < mining_threads; i++) for (i = 0; i < mining_threads; i++)
@ -8063,7 +8063,7 @@ static void restart_mining_threads(unsigned int new_n_threads)
mining_thr[i]->cgpu->shutdown = true; mining_thr[i]->cgpu->shutdown = true;
} }
rd_unlock(&mining_thr_lock); rd_unlock(&mining_thr_lock);
// kill_mining will rd lock mining_thr_lock // kill_mining will rd lock mining_thr_lock
kill_mining(); kill_mining();
rd_lock(&mining_thr_lock); rd_lock(&mining_thr_lock);
@ -8078,16 +8078,16 @@ static void restart_mining_threads(unsigned int new_n_threads)
wr_lock(&mining_thr_lock); wr_lock(&mining_thr_lock);
if (mining_thr) if (mining_thr)
{ {
for (i = 0; i < total_devices; i++) { for (i = 0; i < total_devices; i++) {
if (devices[i]->thr) free(devices[i]->thr); if (devices[i]->thr) free(devices[i]->thr);
} }
for (i = 0; i < mining_threads; i++) { for (i = 0; i < mining_threads; i++) {
free(mining_thr[i]); free(mining_thr[i]);
} }
free(mining_thr); free(mining_thr);
} }
@ -8106,15 +8106,15 @@ static void restart_mining_threads(unsigned int new_n_threads)
} }
rd_lock(&devices_lock); rd_lock(&devices_lock);
// Start threads // Start threads
struct pool *pool; struct pool *pool;
if(gpu_initialized) if(gpu_initialized)
pool = current_pool(); pool = current_pool();
else else
pool = pools[init_pool]; pool = pools[init_pool];
k = 0; k = 0;
for (i = 0; i < total_devices; ++i) { for (i = 0; i < total_devices; ++i) {
struct cgpu_info *cgpu = devices[i]; struct cgpu_info *cgpu = devices[i];
@ -8128,7 +8128,7 @@ static void restart_mining_threads(unsigned int new_n_threads)
cgpu->thr[cgpu->threads] = NULL; cgpu->thr[cgpu->threads] = NULL;
cgpu->status = LIFE_INIT; cgpu->status = LIFE_INIT;
for (j = 0; j < cgpu->threads; ++j, ++k) for (j = 0; j < cgpu->threads; ++j, ++k)
{ {
thr = mining_thr[k]; thr = mining_thr[k];
thr->id = k; thr->id = k;
@ -8172,15 +8172,15 @@ static void *restart_mining_threads_thread(void *userdata)
{ {
//get thread id //get thread id
pthread_t t = pthread_self(); pthread_t t = pthread_self();
//detach //detach
pthread_detach(t); pthread_detach(t);
#ifdef __TEMP_ALGO_SWITCH_FIX__ #ifdef __TEMP_ALGO_SWITCH_FIX__
//put in list of active threads //put in list of active threads
thread_fix_push(t); thread_fix_push(t);
#endif /* __TEMP_ALGO_SWITCH_FIX__ */ #endif /* __TEMP_ALGO_SWITCH_FIX__ */
//restart mining threads //restart mining threads
restart_mining_threads((unsigned int) (intptr_t) userdata); restart_mining_threads((unsigned int) (intptr_t) userdata);
@ -8192,7 +8192,6 @@ static void *restart_mining_threads_thread(void *userdata)
} }
#define DRIVER_FILL_DEVICE_DRV(X) fill_device_drv(&X##_drv); #define DRIVER_FILL_DEVICE_DRV(X) fill_device_drv(&X##_drv);
#define DRIVER_DRV_DETECT_ALL(X) X##_drv.drv_detect(false);
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
@ -8370,7 +8369,7 @@ int main(int argc, char *argv[])
DRIVER_PARSE_COMMANDS(DRIVER_FILL_DEVICE_DRV) DRIVER_PARSE_COMMANDS(DRIVER_FILL_DEVICE_DRV)
// this will set total_devices // this will set total_devices
opencl_drv.drv_detect(false); opencl_drv.drv_detect();
if (opt_display_devs) { if (opt_display_devs) {
applog(LOG_ERR, "Devices detected:"); applog(LOG_ERR, "Devices detected:");
@ -8539,7 +8538,7 @@ int main(int argc, char *argv[])
sleep(1); sleep(1);
slept++; slept++;
} while (!gpu_initialized && slept < 60); } while (!gpu_initialized && slept < 60);
if(slept >= 60) if(slept >= 60)
applog(LOG_WARNING, "GPUs did not become initialized in 60 seconds..."); applog(LOG_WARNING, "GPUs did not become initialized in 60 seconds...");

Write Preview
Loading…
Cancel
Save