Fixed x13 and other issues

Corrected the x13 errors and fixed a few issues with the config parser's
handling of the default_profile.

api.c

@@ -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;

config_parser.c

@@ -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 (!empty_string(default_profile.devices))
-    set_devices((char *)default_profile.devices);
-
-  if (!empty_string(default_profile.intensity))
-    set_intensity(default_profile.intensity);
+  //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.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);
+      //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;
+  }
 
-      pool->intensity = profile->intensity;
-      applog(LOG_DEBUG, "Pool %i Intensity set to \"%s\"", pool->pool_no, pool->intensity);
+  //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);
 
-      pool->xintensity = profile->xintensity;
-      applog(LOG_DEBUG, "Pool %i XIntensity set to \"%s\"", pool->pool_no, pool->xintensity);
+  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);
 
-      pool->rawintensity = profile->rawintensity;
-      applog(LOG_DEBUG, "Pool %i Raw Intensity set to \"%s\"", pool->pool_no, pool->rawintensity);
+  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);
 
-      pool->thread_concurrency = profile->thread_concurrency;
-      applog(LOG_DEBUG, "Pool %i Thread Concurrency set to \"%s\"", pool->pool_no, pool->thread_concurrency);
+  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);
 
-#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);
+  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);
 
-      pool->gpu_memclock = profile->gpu_memclock;
-      applog(LOG_DEBUG, "Pool %i GPU Memory clock set to \"%s\"", pool->pool_no, pool->gpu_memclock);
+  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);
 
-      pool->gpu_threads = profile->gpu_threads;
-      applog(LOG_DEBUG, "Pool %i GPU Threads set to \"%s\"", pool->pool_no, pool->gpu_threads);
+  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);
 
-      pool->gpu_fan = profile->gpu_fan;
-      applog(LOG_DEBUG, "Pool %i GPU Fan set to \"%s\"", pool->pool_no, pool->gpu_fan);
+  #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);
 
-      pool->gpu_powertune = profile->gpu_powertune;
-      applog(LOG_DEBUG, "Pool %i GPU Powertune set to \"%s\"", pool->pool_no, pool->gpu_powertune);
+    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);
 
-      pool->gpu_vddc = profile->gpu_vddc;
-      applog(LOG_DEBUG, "Pool %i GPU Vddc set to \"%s\"", pool->pool_no, pool->gpu_vddc);
-#endif
+    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);
 
-      pool->shaders = profile->shaders;
-      applog(LOG_DEBUG, "Pool %i Shaders set to \"%s\"", pool->pool_no, pool->shaders);
+    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);
 
-      pool->worksize = profile->worksize;
-      applog(LOG_DEBUG, "Pool %i Worksize set to \"%s\"", pool->pool_no, pool->worksize);
+    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;
     }
-    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);
-      //remove profile name
-      pool->profile[0] = '\0';
+      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;

config_parser.h

@@ -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);

driver-opencl.c

@@ -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);
   }
 

kernel/marucoin-mod.cl

@@ -203,7 +203,7 @@ __kernel void search1(__global hash_t* hashes)
   mv[12] = 0;
   mv[13] = 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]);
   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[15] = SWAP4(S30);
 
-  bool result = (hash.h8[3] <= target);
+  bool result = (hash->h8[3] <= target);
   if (result)
     output[atomic_inc(output+0xFF)] = SWAP4(gid);
 

miner.h

@@ -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;

sgminer.c

@@ -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;