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

Fixed x13 and other issues 

Corrected the x13 errors and fixed a few issues with the config parser's
handling of the default_profile.
djm34
ystarnaud 11 years ago
parent
298a752150
commit
1914cef959
7 changed files with 312 additions and 191 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. 4
      api.c
  2. 219
      config_parser.c
  3. 7
      config_parser.h
  4. 3
      driver-opencl.c
  5. 4
      kernel/marucoin-mod.cl
  6. 2
      miner.h
  7. 256
      sgminer.c

4
api.c
Unescape View File

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

219
config_parser.c
Unescape View File

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

7
config_parser.h
Unescape View File

@ -12,7 +12,10 @@
#define empty_string(str) ((str && str[0] != '\0')?0:1) #define empty_string(str) ((str && str[0] != '\0')?0:1)
#endif #endif
#ifndef safe_cmp #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 #endif
#ifndef isnull #ifndef isnull
#define isnull(str, default_str) ((str == NULL)?default_str:str) #define isnull(str, default_str) ((str == NULL)?default_str:str)
@ -60,6 +63,8 @@ extern struct profile **profiles;
extern int total_profiles; extern int total_profiles;
/* option parser functions */ /* 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_devices(const char *arg);
extern char *set_default_lookup_gap(const char *arg); extern char *set_default_lookup_gap(const char *arg);
extern char *set_default_intensity(const char *arg); extern char *set_default_intensity(const char *arg);

3
driver-opencl.c
Unescape View File

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

4
kernel/marucoin-mod.cl
Unescape View File

@ -203,7 +203,7 @@ __kernel void search1(__global hash_t* hashes)
mv[12] = 0; mv[12] = 0;
mv[13] = 0; mv[13] = 0;
mv[14] = 0; mv[14] = 0;
mv[15] = SPH_C64(512) mv[15] = SPH_C64(512);
tmp = (mv[5] ^ BMW_H[5]) - (mv[7] ^ BMW_H[7]) + (mv[10] ^ BMW_H[10]) + (mv[13] ^ BMW_H[13]) + (mv[14] ^ BMW_H[14]); tmp = (mv[5] ^ BMW_H[5]) - (mv[7] ^ BMW_H[7]) + (mv[10] ^ BMW_H[10]) + (mv[13] ^ BMW_H[13]) + (mv[14] ^ BMW_H[14]);
q[0] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ SPH_ROTL64(tmp, 4) ^ SPH_ROTL64(tmp, 37)) + BMW_H[1]; q[0] = (SHR(tmp, 1) ^ SHL(tmp, 3) ^ SPH_ROTL64(tmp, 4) ^ SPH_ROTL64(tmp, 37)) + BMW_H[1];
@ -1234,7 +1234,7 @@ __kernel void search12(__global hash_t* hashes, __global uint* output, const ulo
hash->h4[14] = SWAP4(S29); hash->h4[14] = SWAP4(S29);
hash->h4[15] = SWAP4(S30); hash->h4[15] = SWAP4(S30);
bool result = (hash.h8[3] <= target); bool result = (hash->h8[3] <= target);
if (result) if (result)
output[atomic_inc(output+0xFF)] = SWAP4(gid); output[atomic_inc(output+0xFF)] = SWAP4(gid);

2
miner.h
Unescape View File

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

256
sgminer.c
Unescape View File

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

Write Preview
Loading…
Cancel
Save