GOSTSec/sgminer
1
0
Fork 0
mirror of https://github.com/GOSTSec/sgminer synced 2025-01-22 12:34:27 +00:00
Code Issues Releases Wiki Activity

Merge pull request #282 from ystarnaud/x11mod

Browse Source 
Updated x11 and x13 kernels
This commit is contained in:
ystarnaud 2014-06-21 18:33:24 -04:00
commit 707ddd6c4a
8 changed files with 2238 additions and 9194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
api.c
View File

@ -3585,7 +3585,7 @@ void api(int api_thr_id)
struct sockaddr_in cli;
socklen_t clisiz;
char cmdbuf[100];
char *cmd = NULL, *cmdptr, *cmdsbuf;
char *cmd = NULL, *cmdptr, *cmdsbuf = NULL;
char *param;
bool addrok;
char group;
@ -3593,7 +3593,7 @@ void api(int api_thr_id)
json_t *json_config = NULL;
json_t *json_val;
bool isjson;
bool did, isjoin, firstjoin;
bool did, isjoin = false, firstjoin;
int i;
SOCKETTYPE *apisock;

245
config_parser.c
View File

@ -83,6 +83,7 @@ static struct profile *add_profile()
//default profile name is the profile index
sprintf(buf, "%d", profile->profile_no);
profile->name = strdup(buf);
profile->algorithm.name[0] = '\0';
profiles = (struct profile **)realloc(profiles, sizeof(struct profile *) * (total_profiles + 2));
profiles[total_profiles++] = profile;
@ -146,6 +147,22 @@ static struct profile *get_profile(char *name)
}
/******* Default profile functions used during config parsing *****/
char *set_default_algorithm(const char *arg)
{
set_algorithm(&default_profile.algorithm, arg);
applog(LOG_INFO, "Set default algorithm to %s", default_profile.algorithm.name);
return NULL;
}
char *set_default_nfactor(const char *arg)
{
set_algorithm_nfactor(&default_profile.algorithm, (const uint8_t) atoi(arg));
applog(LOG_INFO, "Set algorithm N-factor to %d (N to %d)", default_profile.algorithm.nfactor);
return NULL;
}
char *set_default_devices(const char *arg)
{
default_profile.devices = arg;
@ -696,19 +713,24 @@ void load_default_profile()
//apply default settings
void apply_defaults()
{
set_algorithm(&opt_algorithm, default_profile.algorithm.name);
//if no algorithm specified, use scrypt as default
if (empty_string(default_profile.algorithm.name))
set_algorithm(&default_profile.algorithm, "scrypt");
if (!empty_string(default_profile.devices))
set_devices((char *)default_profile.devices);
if (!empty_string(default_profile.intensity))
set_intensity(default_profile.intensity);
if (!empty_string(default_profile.xintensity))
set_xintensity(default_profile.xintensity);
//by default all unless specified
if (empty_string(default_profile.devices))
default_profile.devices = strdup("all");
set_devices((char *)default_profile.devices);
//set raw intensity first
if (!empty_string(default_profile.rawintensity))
set_rawintensity(default_profile.rawintensity);
//then try xintensity
else if (!empty_string(default_profile.xintensity))
set_xintensity(default_profile.xintensity);
//then try intensity
else if (!empty_string(default_profile.intensity))
set_intensity(default_profile.intensity);
if (!empty_string(default_profile.lookup_gap))
set_lookup_gap((char *)default_profile.lookup_gap);
@ -758,68 +780,167 @@ void apply_pool_profile(struct pool *pool)
{
struct profile *profile;
//if the pool has a profile set
//if the pool has a profile set load it
if(!empty_string(pool->profile))
{
applog(LOG_DEBUG, "Loading settings from profile \"%s\" for pool %i", pool->profile, pool->pool_no);
//find profile and apply settings to the pool
if((profile = get_profile(pool->profile)))
if(!(profile = get_profile(pool->profile)))
{
pool->algorithm = profile->algorithm;
applog(LOG_DEBUG, "Pool %i Algorithm set to \"%s\"", pool->pool_no, pool->algorithm.name);
pool->devices = profile->devices;
applog(LOG_DEBUG, "Pool %i devices set to \"%s\"", pool->pool_no, pool->devices);
pool->lookup_gap = profile->lookup_gap;
applog(LOG_DEBUG, "Pool %i lookup gap set to \"%s\"", pool->pool_no, pool->lookup_gap);
pool->intensity = profile->intensity;
applog(LOG_DEBUG, "Pool %i Intensity set to \"%s\"", pool->pool_no, pool->intensity);
pool->xintensity = profile->xintensity;
applog(LOG_DEBUG, "Pool %i XIntensity set to \"%s\"", pool->pool_no, pool->xintensity);
pool->rawintensity = profile->rawintensity;
applog(LOG_DEBUG, "Pool %i Raw Intensity set to \"%s\"", pool->pool_no, pool->rawintensity);
pool->thread_concurrency = profile->thread_concurrency;
applog(LOG_DEBUG, "Pool %i Thread Concurrency set to \"%s\"", pool->pool_no, pool->thread_concurrency);
#ifdef HAVE_ADL
pool->gpu_engine = profile->gpu_engine;
applog(LOG_DEBUG, "Pool %i GPU Clock set to \"%s\"", pool->pool_no, pool->gpu_engine);
pool->gpu_memclock = profile->gpu_memclock;
applog(LOG_DEBUG, "Pool %i GPU Memory clock set to \"%s\"", pool->pool_no, pool->gpu_memclock);
pool->gpu_threads = profile->gpu_threads;
applog(LOG_DEBUG, "Pool %i GPU Threads set to \"%s\"", pool->pool_no, pool->gpu_threads);
pool->gpu_fan = profile->gpu_fan;
applog(LOG_DEBUG, "Pool %i GPU Fan set to \"%s\"", pool->pool_no, pool->gpu_fan);
pool->gpu_powertune = profile->gpu_powertune;
applog(LOG_DEBUG, "Pool %i GPU Powertune set to \"%s\"", pool->pool_no, pool->gpu_powertune);
pool->gpu_vddc = profile->gpu_vddc;
applog(LOG_DEBUG, "Pool %i GPU Vddc set to \"%s\"", pool->pool_no, pool->gpu_vddc);
#endif
pool->shaders = profile->shaders;
applog(LOG_DEBUG, "Pool %i Shaders set to \"%s\"", pool->pool_no, pool->shaders);
pool->worksize = profile->worksize;
applog(LOG_DEBUG, "Pool %i Worksize set to \"%s\"", pool->pool_no, pool->worksize);
}
else
{
applog(LOG_DEBUG, "Profile load failed for pool %i: profile %s not found.", pool->pool_no, pool->profile);
//if not found, remove profile name and use default profile.
applog(LOG_DEBUG, "Profile load failed for pool %i: profile %s not found. Using default profile.", pool->pool_no, pool->profile);
//remove profile name
pool->profile[0] = '\0';
profile = &default_profile;
}
}
//no profile specified in pool, use default profile
else
{
applog(LOG_DEBUG, "Loading settings from default_profile for pool %i", pool->profile, pool->pool_no);
profile = &default_profile;
}
//only apply profiles settings not already defined in the pool
//if no algorithm is specified, use profile's or default profile's
if(empty_string(pool->algorithm.name))
{
if(!empty_string(profile->algorithm.name))
pool->algorithm = profile->algorithm;
else
pool->algorithm = default_profile.algorithm;
}
applog(LOG_DEBUG, "Pool %i Algorithm set to \"%s\"", pool->pool_no, pool->algorithm.name);
if(pool_cmp(pool->devices, default_profile.devices))
{
if(!empty_string(profile->devices))
pool->devices = profile->devices;
else
pool->devices = default_profile.devices;
}
applog(LOG_DEBUG, "Pool %i devices set to \"%s\"", pool->pool_no, pool->devices);
if(pool_cmp(pool->lookup_gap, default_profile.lookup_gap))
{
if(!empty_string(profile->lookup_gap))
pool->lookup_gap = profile->lookup_gap;
else
pool->lookup_gap = default_profile.lookup_gap;
}
applog(LOG_DEBUG, "Pool %i lookup gap set to \"%s\"", pool->pool_no, pool->lookup_gap);
if(pool_cmp(pool->intensity, default_profile.intensity))
{
if(!empty_string(profile->intensity))
pool->intensity = profile->intensity;
else
pool->intensity = default_profile.intensity;
}
applog(LOG_DEBUG, "Pool %i Intensity set to \"%s\"", pool->pool_no, pool->intensity);
if(pool_cmp(pool->xintensity, default_profile.xintensity))
{
if(!empty_string(profile->xintensity))
pool->xintensity = profile->xintensity;
else
pool->xintensity = default_profile.xintensity;
}
applog(LOG_DEBUG, "Pool %i XIntensity set to \"%s\"", pool->pool_no, pool->xintensity);
if(pool_cmp(pool->rawintensity, default_profile.rawintensity))
{
if(!empty_string(profile->rawintensity))
pool->rawintensity = profile->rawintensity;
else
pool->rawintensity = default_profile.rawintensity;
}
applog(LOG_DEBUG, "Pool %i Raw Intensity set to \"%s\"", pool->pool_no, pool->rawintensity);
if(pool_cmp(pool->thread_concurrency, default_profile.thread_concurrency))
{
if(!empty_string(profile->thread_concurrency))
pool->thread_concurrency = profile->thread_concurrency;
else
pool->thread_concurrency = default_profile.thread_concurrency;
}
applog(LOG_DEBUG, "Pool %i Thread Concurrency set to \"%s\"", pool->pool_no, pool->thread_concurrency);
#ifdef HAVE_ADL
if(pool_cmp(pool->gpu_engine, default_profile.gpu_engine))
{
if(!empty_string(profile->gpu_engine))
pool->gpu_engine = profile->gpu_engine;
else
pool->gpu_engine = default_profile.gpu_engine;
}
applog(LOG_DEBUG, "Pool %i GPU Clock set to \"%s\"", pool->pool_no, pool->gpu_engine);
if(pool_cmp(pool->gpu_memclock, default_profile.gpu_memclock))
{
if(!empty_string(profile->gpu_memclock))
pool->gpu_memclock = profile->gpu_memclock;
else
pool->gpu_memclock = default_profile.gpu_memclock;
}
applog(LOG_DEBUG, "Pool %i GPU Memory clock set to \"%s\"", pool->pool_no, pool->gpu_memclock);
if(pool_cmp(pool->gpu_threads, default_profile.gpu_threads))
{
if(!empty_string(profile->gpu_threads))
pool->gpu_threads = profile->gpu_threads;
else
pool->gpu_threads = default_profile.gpu_threads;
}
applog(LOG_DEBUG, "Pool %i GPU Threads set to \"%s\"", pool->pool_no, pool->gpu_threads);
if(pool_cmp(pool->gpu_fan, default_profile.gpu_fan))
{
if(!empty_string(profile->gpu_fan))
pool->gpu_fan = profile->gpu_fan;
else
pool->gpu_fan = default_profile.gpu_fan;
}
applog(LOG_DEBUG, "Pool %i GPU Fan set to \"%s\"", pool->pool_no, pool->gpu_fan);
if(pool_cmp(pool->gpu_powertune, default_profile.gpu_powertune))
{
if(!empty_string(profile->gpu_powertune))
pool->gpu_powertune = profile->gpu_powertune;
else
pool->gpu_powertune = default_profile.gpu_powertune;
}
applog(LOG_DEBUG, "Pool %i GPU Powertune set to \"%s\"", pool->pool_no, pool->gpu_powertune);
if(pool_cmp(pool->gpu_vddc, default_profile.gpu_vddc))
{
if(!empty_string(profile->gpu_vddc))
pool->gpu_vddc = profile->gpu_vddc;
else
pool->gpu_vddc = default_profile.gpu_vddc;
}
applog(LOG_DEBUG, "Pool %i GPU Vddc set to \"%s\"", pool->pool_no, pool->gpu_vddc);
#endif
if(pool_cmp(pool->shaders, default_profile.shaders))
{
if(!empty_string(profile->shaders))
pool->shaders = profile->shaders;
else
pool->shaders = default_profile.shaders;
}
applog(LOG_DEBUG, "Pool %i Shaders set to \"%s\"", pool->pool_no, pool->shaders);
if(pool_cmp(pool->worksize, default_profile.worksize))
{
if(!empty_string(profile->worksize))
pool->worksize = profile->worksize;
else
pool->worksize = default_profile.worksize;
}
applog(LOG_DEBUG, "Pool %i Worksize set to \"%s\"", pool->pool_no, pool->worksize);
}
//helper function to add json values to pool object
@ -1291,7 +1412,7 @@ void write_config(const char *filename)
else
{
//save algorithm name
if(json_object_set(config, "algorithm", json_string(opt_algorithm.name)) == -1)
if(json_object_set(config, "algorithm", json_string(default_profile.algorithm.name)) == -1)
{
applog(LOG_ERR, "Error: config_parser::write_config():\n json_object_set() failed on algorithm");
return;

7
config_parser.h
View File

@ -12,7 +12,10 @@
#define empty_string(str) ((str && str[0] != '\0')?0:1)
#endif
#ifndef safe_cmp
#define safe_cmp(val1, val2) (((val1 && strcmp(val1, val2) != 0) || empty_string(val1))?1:0)
#define safe_cmp(val1, val2) (((val1 && strcasecmp(val1, val2) != 0) || empty_string(val1))?1:0)
#endif
#ifndef pool_cmp
#define pool_cmp(val1, val2) (((val1 && val2 && strcasecmp(val1, val2) == 0) || empty_string(val1))?1:0)
#endif
#ifndef isnull
#define isnull(str, default_str) ((str == NULL)?default_str:str)
@ -60,6 +63,8 @@ extern struct profile **profiles;
extern int total_profiles;
/* option parser functions */
extern char *set_default_algorithm(const char *arg);
extern char *set_default_nfactor(const char *arg);
extern char *set_default_devices(const char *arg);
extern char *set_default_lookup_gap(const char *arg);
extern char *set_default_intensity(const char *arg);

3
driver-opencl.c
View File

@ -28,6 +28,7 @@
#include "compat.h"
#include "miner.h"
#include "config_parser.h"
#include "driver-opencl.h"
#include "findnonce.h"
#include "ocl.h"
@ -1161,7 +1162,7 @@ static void opencl_detect(bool hotplug)
cgpu->threads = 1;
#endif
cgpu->virtual_gpu = i;
cgpu->algorithm = opt_algorithm;
cgpu->algorithm = default_profile.algorithm;
add_cgpu(cgpu);
}

9181
kernel/darkcoin-mod.cl
View File

File diff suppressed because it is too large Load Diff

1728
kernel/marucoin-mod.cl
View File

File diff suppressed because it is too large Load Diff

2
miner.h
View File

@ -1008,7 +1008,7 @@ extern int opt_queue;
extern int opt_scantime;
extern int opt_expiry;
extern algorithm_t opt_algorithm;
//extern algorithm_t opt_algorithm;
extern cglock_t control_lock;
extern pthread_mutex_t hash_lock;

262
sgminer.c
View File

@ -91,7 +91,7 @@ int opt_queue = 1;
int opt_scantime = 7;
int opt_expiry = 28;
algorithm_t opt_algorithm;
//algorithm_t opt_algorithm;
unsigned long long global_hashrate;
unsigned long global_quota_gcd = 1;
@ -513,9 +513,7 @@ struct pool *add_pool(void)
buf[0] = '\0';
pool->name = strdup(buf);
pool->profile = strdup(buf); //profile blank by default
/* Algorithm */
pool->algorithm = opt_algorithm;
pool->algorithm.name[0] = '\0'; //blank algorithm name
pools = (struct pool **)realloc(pools, sizeof(struct pool *) * (total_pools + 2));
pools[total_pools++] = pool;
@ -637,25 +635,25 @@ char *set_devices(char *arg)
int i, val1 = 0, val2 = 0;
char *nextptr;
if (*arg)
if(*arg)
{
if (*arg == '?')
{
if (*arg == '?')
{
opt_display_devs = true;
return NULL;
}
//all devices enabled
else if(*arg == '*')
{
applog(LOG_DEBUG, "set_devices(%s)", arg);
opt_devs_enabled = 0;
return NULL;
}
}
else
return "Invalid device parameters";
opt_display_devs = true;
return NULL;
}
//all devices enabled
else if(*arg == '*' || !strcasecmp(arg, "all"))
{
applog(LOG_DEBUG, "set_devices(all)");
opt_devs_enabled = 0;
return NULL;
}
}
else
return "Invalid device parameters";
applog(LOG_DEBUG, "set_devices(%s)", arg);
applog(LOG_DEBUG, "set_devices(%s)", arg);
nextptr = strtok(arg, ",");
if (nextptr == NULL)
@ -1165,31 +1163,6 @@ static void load_temp_cutoffs()
}
}
static char *set_algo(const char *arg)
{
if ((json_array_index < 0) || (total_pools == 0)) {
set_algorithm(&opt_algorithm, arg);
applog(LOG_INFO, "Set default algorithm to %s", opt_algorithm.name);
} else {
set_pool_algorithm(arg);
}
return NULL;
}
static char *set_nfactor(const char *arg)
{
if ((json_array_index < 0) || (total_pools == 0)) {
set_algorithm_nfactor(&opt_algorithm, (const uint8_t) atoi(arg));
applog(LOG_INFO, "Set algorithm N-factor to %d (N to %d)",
opt_algorithm.nfactor, opt_algorithm.n);
} else {
set_pool_nfactor(arg);
}
return NULL;
}
static char *set_api_allow(const char *arg)
{
opt_set_charp(arg, &opt_api_allow);
@ -1251,7 +1224,7 @@ char *set_difficulty_multiplier(char *arg)
/* These options are available from config file or commandline */
struct opt_table opt_config_table[] = {
OPT_WITH_ARG("--algorithm",
set_algo, NULL, NULL,
set_default_algorithm, NULL, NULL,
"Set mining algorithm and most common defaults, default: scrypt"),
OPT_WITH_ARG("--api-allow",
set_api_allow, NULL, NULL,
@ -1437,7 +1410,7 @@ struct opt_table opt_config_table[] = {
opt_set_bool, &opt_delaynet,
"Impose small delays in networking to not overload slow routers"),
OPT_WITH_ARG("--nfactor",
set_nfactor, NULL, NULL,
set_default_nfactor, NULL, NULL,
"Override default scrypt N-factor parameter."),
#ifdef HAVE_ADL
OPT_WITHOUT_ARG("--no-adl",
@ -5907,26 +5880,28 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
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
active_threads = 0;
for(i = 0; i < mining_threads; i++)
{
struct thr_info *thr = mining_thr[i];
if(thr->cgpu->deven != DEV_DISABLED)
active_threads ++;
}
//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;
for(i = 0; i < mining_threads; i++)
{
struct thr_info *thr = mining_thr[i];
if(thr->cgpu->deven != DEV_DISABLED)
active_threads ++;
}
// If all threads are waiting now
if (algo_switch_n >= active_threads)
{
start_threads = mining_threads; //use start_threads below
start_threads = mining_threads; //use start_threads below
bool soft_restart = !work->pool->gpu_threads;
rd_lock(&mining_thr_lock);
// Shutdown all threads first (necessary)
if (soft_restart) {
for (i = 0; i < start_threads; i++) {
if (soft_restart)
{
for (i = 0; i < start_threads; i++)
{
struct thr_info *thr = mining_thr[i];
thr->cgpu->drv->thread_shutdown(thr);
}
@ -5952,87 +5927,103 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
//lookup gap
if(!empty_string(work->pool->lookup_gap))
set_lookup_gap((char *)work->pool->lookup_gap);
else if(!empty_string(default_profile.lookup_gap))
else if(!empty_string(default_profile.lookup_gap))
set_lookup_gap((char *)default_profile.lookup_gap);
//intensity
if(!empty_string(work->pool->intensity))
set_intensity(work->pool->intensity);
else if(!empty_string(default_profile.intensity))
set_intensity(default_profile.intensity);
//xintensity
if (!empty_string(work->pool->xintensity))
set_xintensity(work->pool->xintensity);
else if(!empty_string(default_profile.xintensity))
set_xintensity(default_profile.xintensity);
//raw intensity
//raw intensity from pool
if (!empty_string(work->pool->rawintensity))
set_rawintensity(work->pool->rawintensity);
else if(!empty_string(default_profile.rawintensity))
//raw intensity from default profile
else if(!empty_string(default_profile.rawintensity))
set_rawintensity(default_profile.rawintensity);
//if no rawintensity is set try xintensity
else
{
//xintensity from pool
if (!empty_string(work->pool->xintensity))
set_xintensity(work->pool->xintensity);
//xintensity from default profile
else if(!empty_string(default_profile.xintensity))
set_xintensity(default_profile.xintensity);
//no xintensity set try intensity
else
{
//intensity from pool
if(!empty_string(work->pool->intensity))
set_intensity(work->pool->intensity);
//intensity from defaults
else if(!empty_string(default_profile.intensity))
set_intensity(default_profile.intensity);
//nothing set anywhere, use 8
else
{
default_profile.intensity = strdup("8");
set_intensity(default_profile.intensity);
}
}
}
//shaders
if (!empty_string(work->pool->shaders))
set_shaders((char *)work->pool->shaders);
else if(!empty_string(default_profile.shaders))
else if(!empty_string(default_profile.shaders))
set_shaders((char *)default_profile.shaders);
//worksize
if (!empty_string(work->pool->worksize))
set_worksize((char *)work->pool->worksize);
else if(!empty_string(default_profile.worksize))
else if(!empty_string(default_profile.worksize))
set_worksize((char *)default_profile.worksize);
#ifdef HAVE_ADL
//GPU clock
if(!empty_string(work->pool->gpu_engine))
#ifdef HAVE_ADL
//GPU clock
if(!empty_string(work->pool->gpu_engine))
set_gpu_engine(work->pool->gpu_engine);
else if(!empty_string(default_profile.gpu_engine))
else if(!empty_string(default_profile.gpu_engine))
set_gpu_engine(default_profile.gpu_engine);
//GPU memory clock
if(!empty_string(work->pool->gpu_memclock))
//GPU memory clock
if(!empty_string(work->pool->gpu_memclock))
set_gpu_memclock(work->pool->gpu_memclock);
else if(!empty_string(default_profile.gpu_memclock))
else if(!empty_string(default_profile.gpu_memclock))
set_gpu_memclock(default_profile.gpu_memclock);
//GPU fans
if(!empty_string(work->pool->gpu_fan))
//GPU fans
if(!empty_string(work->pool->gpu_fan))
set_gpu_fan(work->pool->gpu_fan);
else if(!empty_string(default_profile.gpu_fan))
else if(!empty_string(default_profile.gpu_fan))
set_gpu_fan(default_profile.gpu_fan);
//GPU powertune
if(!empty_string(work->pool->gpu_powertune))
//GPU powertune
if(!empty_string(work->pool->gpu_powertune))
set_gpu_powertune((char *)work->pool->gpu_powertune);
else if(!empty_string(default_profile.gpu_powertune))
else if(!empty_string(default_profile.gpu_powertune))
set_gpu_powertune((char *)default_profile.gpu_powertune);
//GPU vddc
if(!empty_string(work->pool->gpu_vddc))
//GPU vddc
if(!empty_string(work->pool->gpu_vddc))
set_gpu_vddc((char *)work->pool->gpu_vddc);
else if(!empty_string(default_profile.gpu_vddc))
else if(!empty_string(default_profile.gpu_vddc))
set_gpu_vddc((char *)default_profile.gpu_vddc);
//apply gpu settings
for (i = 0; i < nDevs; i++)
{
//apply gpu settings
for (i = 0; i < nDevs; i++)
{
set_engineclock(i, gpus[i].min_engine);
set_memoryclock(i, gpus[i].gpu_memclock);
set_fanspeed(i, gpus[i].gpu_fan);
set_powertune(i, gpus[i].gpu_powertune);
set_vddc(i, gpus[i].gpu_vddc);
}
#endif
}
#endif
// Change algorithm for each thread (thread_prepare calls initCl)
for (i = 0; i < start_threads; i++)
{
struct thr_info *thr = mining_thr[i];
thr->cgpu->algorithm = work->pool->algorithm;
if (soft_restart) {
if (soft_restart)
{
thr->cgpu->drv->thread_prepare(thr);
thr->cgpu->drv->thread_init(thr);
}
@ -6040,6 +6031,7 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
// Necessary because algorithms can have dramatically different diffs
thr->cgpu->drv->working_diff = 1;
}
rd_unlock(&mining_thr_lock);
// Finish switching pools
@ -6049,37 +6041,37 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
// Hard restart (when gpu_threads is changed)
if (!soft_restart)
{
//enable/disable devices based on profile/pool/defaults
sgminer_id_count = 0; //reset sgminer_ids
mining_threads = 0; //mining threads gets added inside each enable_device() so reset
if(opt_devs_enabled)
//enable/disable devices based on profile/pool/defaults
sgminer_id_count = 0; //reset sgminer_ids
mining_threads = 0; //mining threads gets added inside each enable_device() so reset
if(opt_devs_enabled)
{
for (i = 0; i < MAX_DEVICES; i++)
{
for (i = 0; i < MAX_DEVICES; i++)
{
//device should be enabled
if(devices_enabled[i] && i < total_devices)
{
applog(LOG_DEBUG, "Enabling device %d", i);
enable_device(devices[i]);
}
else if(i < total_devices)
{
applog(LOG_DEBUG, "Disabling device %d", i);
//if option is set to not remove disabled, enable device
if(!opt_removedisabled)
enable_device(devices[i]);
//mark as disabled
devices[i]->deven = DEV_DISABLED;
}
}
}
//enable all devices
else
{
for (i = 0; i < total_devices; ++i)
enable_device(devices[i]);
//device should be enabled
if(devices_enabled[i] && i < total_devices)
{
applog(LOG_DEBUG, "Enabling device %d", i);
enable_device(devices[i]);
}
else if(i < total_devices)
{
applog(LOG_DEBUG, "Disabling device %d", i);
//if option is set to not remove disabled, enable device
if(!opt_removedisabled)
enable_device(devices[i]);
//mark as disabled
devices[i]->deven = DEV_DISABLED;
}
}
}
//enable all devices
else
{
for (i = 0; i < total_devices; ++i)
enable_device(devices[i]);
}
//devices reset - assign gpu-threads as needed
@ -6087,12 +6079,12 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
pthread_t restart_thr;
#ifdef HAVE_ADL
if(!empty_string(work->pool->gpu_threads))
set_gpu_threads(work->pool->gpu_threads);
set_gpu_threads(work->pool->gpu_threads);
else if(!empty_string(default_profile.gpu_threads))
set_gpu_threads(default_profile.gpu_threads);
set_gpu_threads(default_profile.gpu_threads);
for (i = 0; i < total_devices; ++i)
n_threads += devices[i]->threads;
n_threads += devices[i]->threads;
#else
n_threads = mining_threads;
#endif
@ -6111,7 +6103,9 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work)
pthread_cond_broadcast(&algo_switch_wait_cond);
mutex_unlock(&algo_switch_wait_lock);
// Not all threads are waiting, join the waiting list
} else {
}
else
{
mutex_unlock(&algo_switch_lock);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
// Wait for signal to start working again
@ -7785,7 +7779,7 @@ int main(int argc, char *argv[])
#endif
/* Default algorithm specified in algorithm.c ATM */
set_algorithm(&opt_algorithm, "scrypt");
set_algorithm(&default_profile.algorithm, "scrypt");
devcursor = 8;
logstart = devcursor + 1;