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

Fixed whitespaces 

Cleaned up whitespaces in code
djm34
Yann St. Arnaud 10 years ago committed by Noel Maersk
parent
9faa8fa59f
commit
03379f9f51
2 changed files with 334 additions and 334 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. 638
      config_parser.c
  2. 30
      config_parser.h

638
config_parser.c
Unescape View File

@ -7,7 +7,7 @@
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free * under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 3 of the License, or (at your option) * Software Foundation; either version 3 of the License, or (at your option)
* any later version. See COPYING for more details. * any later version. See COPYING for more details.
*/ */
#include "config.h" #include "config.h"
@ -43,20 +43,20 @@
#include "pool.h" #include "pool.h"
#if defined(unix) || defined(__APPLE__) #if defined(unix) || defined(__APPLE__)
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <sys/wait.h> #include <sys/wait.h>
#endif #endif
char *cnfbuf = NULL; //config file loaded char *cnfbuf = NULL; //config file loaded
int fileconf_load; //config file load status int fileconf_load; //config file load status
const char def_conf[] = "sgminer.conf"; const char def_conf[] = "sgminer.conf";
char *default_config; char *default_config;
bool config_loaded; bool config_loaded;
//static int include_count; //static int include_count;
int json_array_index = -1; //current array index being parsed int json_array_index = -1; //current array index being parsed
char *last_json_error = NULL; //last json_error char *last_json_error = NULL; //last json_error
//#define JSON_INCLUDE_CONF "include" //#define JSON_INCLUDE_CONF "include"
#define JSON_LOAD_ERROR "JSON decode of file '%s' failed\n %s" #define JSON_LOAD_ERROR "JSON decode of file '%s' failed\n %s"
#define JSON_LOAD_ERROR_LEN strlen(JSON_LOAD_ERROR) #define JSON_LOAD_ERROR_LEN strlen(JSON_LOAD_ERROR)
@ -72,37 +72,37 @@ int total_profiles;
static struct profile *add_profile() static struct profile *add_profile()
{ {
struct profile *profile; struct profile *profile;
char buf[32]; char buf[32];
if(!(profile = (struct profile *)calloc(sizeof(struct profile), 1))) if(!(profile = (struct profile *)calloc(sizeof(struct profile), 1)))
quit(1, "Failed to calloc profile in add_profile"); quit(1, "Failed to calloc profile in add_profile");
profile->profile_no = total_profiles; profile->profile_no = total_profiles;
//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);
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;
return profile; return profile;
} }
//only used while loading config //only used while loading config
static struct profile *get_current_profile() static struct profile *get_current_profile()
{ {
while ((json_array_index + 1) > total_profiles) while ((json_array_index + 1) > total_profiles)
add_profile(); add_profile();
if (json_array_index < 0) if (json_array_index < 0)
{ {
if (!total_profiles) if (!total_profiles)
add_profile(); add_profile();
return profiles[total_profiles - 1]; return profiles[total_profiles - 1];
} }
return profiles[json_array_index]; return profiles[json_array_index];
} }
//find a profile by name //find a profile by name
@ -122,54 +122,54 @@ static struct profile *get_profile(char *name)
/******* Default profile functions used during config parsing *****/ /******* Default profile functions used during config parsing *****/
char *set_default_intensity(const char *arg) char *set_default_intensity(const char *arg)
{ {
default_profile.intensity = arg; default_profile.intensity = arg;
return NULL; return NULL;
} }
char *set_default_xintensity(const char *arg) char *set_default_xintensity(const char *arg)
{ {
default_profile.xintensity = arg; default_profile.xintensity = arg;
return NULL; return NULL;
} }
char *set_default_rawintensity(const char *arg) char *set_default_rawintensity(const char *arg)
{ {
default_profile.rawintensity = arg; default_profile.rawintensity = arg;
return NULL; return NULL;
} }
char *set_default_thread_concurrency(const char *arg) char *set_default_thread_concurrency(const char *arg)
{ {
default_profile.thread_concurrency = arg; default_profile.thread_concurrency = arg;
return NULL; return NULL;
} }
#ifdef HAVE_ADL #ifdef HAVE_ADL
char *set_default_gpu_engine(const char *arg) char *set_default_gpu_engine(const char *arg)
{ {
default_profile.gpu_engine = arg; default_profile.gpu_engine = arg;
return NULL; return NULL;
} }
char *set_default_gpu_memclock(const char *arg) char *set_default_gpu_memclock(const char *arg)
{ {
default_profile.gpu_memclock = arg; default_profile.gpu_memclock = arg;
return NULL; return NULL;
} }
char *set_default_gpu_threads(const char *arg) char *set_default_gpu_threads(const char *arg)
{ {
default_profile.gpu_threads = arg; default_profile.gpu_threads = arg;
return NULL; return NULL;
} }
char *set_default_gpu_fan(const char *arg) char *set_default_gpu_fan(const char *arg)
{ {
default_profile.gpu_fan = arg; default_profile.gpu_fan = arg;
return NULL; return NULL;
} }
#endif #endif
char *set_default_profile(char *arg) char *set_default_profile(char *arg)
@ -181,213 +181,213 @@ char *set_default_profile(char *arg)
/****** Profile functions used in during config parsing ********/ /****** Profile functions used in during config parsing ********/
char *set_profile_name(char *arg) char *set_profile_name(char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
applog(LOG_DEBUG, "Setting profile %i name to %s", profile->profile_no, arg); applog(LOG_DEBUG, "Setting profile %i name to %s", profile->profile_no, arg);
opt_set_charp(arg, &profile->name); opt_set_charp(arg, &profile->name);
return NULL; return NULL;
} }
char *set_profile_algorithm(const char *arg) char *set_profile_algorithm(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
//applog(LOG_DEBUG, "Setting profile %s algorithm to %s", profile->name, arg); //applog(LOG_DEBUG, "Setting profile %s algorithm to %s", profile->name, arg);
set_algorithm(&profile->algorithm, arg); set_algorithm(&profile->algorithm, arg);
return NULL; return NULL;
} }
char *set_profile_intensity(const char *arg) char *set_profile_intensity(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
profile->intensity = arg; profile->intensity = arg;
return NULL; return NULL;
} }
char *set_profile_xintensity(const char *arg) char *set_profile_xintensity(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
profile->xintensity = arg; profile->xintensity = arg;
return NULL; return NULL;
} }
char *set_profile_rawintensity(const char *arg) char *set_profile_rawintensity(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
profile->rawintensity = arg; profile->rawintensity = arg;
return NULL; return NULL;
} }
char *set_profile_thread_concurrency(const char *arg) char *set_profile_thread_concurrency(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
profile->thread_concurrency = arg; profile->thread_concurrency = arg;
return NULL; return NULL;
} }
#ifdef HAVE_ADL #ifdef HAVE_ADL
char *set_profile_gpu_engine(const char *arg) char *set_profile_gpu_engine(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
profile->gpu_engine = arg; profile->gpu_engine = arg;
return NULL; return NULL;
} }
char *set_profile_gpu_memclock(const char *arg) char *set_profile_gpu_memclock(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
profile->gpu_memclock = arg; profile->gpu_memclock = arg;
return NULL; return NULL;
} }
char *set_profile_gpu_threads(const char *arg) char *set_profile_gpu_threads(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
profile->gpu_threads = arg; profile->gpu_threads = arg;
return NULL; return NULL;
} }
char *set_profile_gpu_fan(const char *arg) char *set_profile_gpu_fan(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
profile->gpu_fan = arg; profile->gpu_fan = arg;
return NULL; return NULL;
} }
#endif #endif
char *set_profile_nfactor(const char *arg) char *set_profile_nfactor(const char *arg)
{ {
struct profile *profile = get_current_profile(); struct profile *profile = get_current_profile();
applog(LOG_DEBUG, "Setting profile %s N-factor to %s", profile->name, arg); applog(LOG_DEBUG, "Setting profile %s N-factor to %s", profile->name, arg);
set_algorithm_nfactor(&profile->algorithm, (const uint8_t) atoi(arg)); set_algorithm_nfactor(&profile->algorithm, (const uint8_t) atoi(arg));
return NULL; return NULL;
} }
/*************************************** /***************************************
* Helper Functions * Helper Functions
****************************************/ ****************************************/
//set last json error //set last json error
void set_last_json_error(const char *fmt, ...) void set_last_json_error(const char *fmt, ...)
{ {
va_list args; va_list args;
size_t bufsize; size_t bufsize;
//build args //build args
va_start(args, fmt); va_start(args, fmt);
//get final string buffer size //get final string buffer size
bufsize = vsnprintf(NULL, 0, JSON_LOAD_ERROR, args); bufsize = vsnprintf(NULL, 0, JSON_LOAD_ERROR, args);
va_end(args); va_end(args);
//if NULL allocate memory... otherwise reallocate //if NULL allocate memory... otherwise reallocate
if(!last_json_error) if(!last_json_error)
{ {
if(!(last_json_error = (char *)malloc(bufsize+1))) if(!(last_json_error = (char *)malloc(bufsize+1)))
quit(1, "Malloc failure in json error"); quit(1, "Malloc failure in json error");
} }
else else
{ {
if(!(last_json_error = (char *)realloc(last_json_error, bufsize+1))) if(!(last_json_error = (char *)realloc(last_json_error, bufsize+1)))
quit(1, "Realloc failure in json error"); quit(1, "Realloc failure in json error");
} }
//zero out buffer //zero out buffer
memset(last_json_error, '\0', bufsize+1); memset(last_json_error, '\0', bufsize+1);
//get args again //get args again
va_start(args, fmt); va_start(args, fmt);
vsnprintf(last_json_error, bufsize, JSON_LOAD_ERROR, args); vsnprintf(last_json_error, bufsize, JSON_LOAD_ERROR, args);
va_end(args); va_end(args);
} }
//find opt by name in an opt table //find opt by name in an opt table
static struct opt_table *opt_find(struct opt_table *tbl, char *optname) static struct opt_table *opt_find(struct opt_table *tbl, char *optname)
{ {
struct opt_table *opt; struct opt_table *opt;
char *p, *name; char *p, *name;
for(opt = tbl;opt->type != OPT_END;opt++) for(opt = tbl;opt->type != OPT_END;opt++)
{ {
/* We don't handle subtables. */ /* We don't handle subtables. */
assert(!(opt->type & OPT_SUBTABLE)); assert(!(opt->type & OPT_SUBTABLE));
if(!opt->names) if(!opt->names)
continue; continue;
/* Pull apart the option name(s). */ /* Pull apart the option name(s). */
name = strdup(opt->names); name = strdup(opt->names);
for(p = strtok(name, "|");p;p = strtok(NULL, "|")) for(p = strtok(name, "|");p;p = strtok(NULL, "|"))
{ {
/* Ignore short options. */ /* Ignore short options. */
if(p[1] != '-') if(p[1] != '-')
continue; continue;
//if this is the opt we're looking for, return it... //if this is the opt we're looking for, return it...
if(!strcasecmp(optname, p)) if(!strcasecmp(optname, p))
{ {
free(name); free(name);
return opt; return opt;
} }
} }
free(name); free(name);
} }
return NULL; return NULL;
} }
/*************************************** /***************************************
* Config Parsing Functions * Config Parsing Functions
****************************************/ ****************************************/
//Handle parsing JSON objects //Handle parsing JSON objects
void parse_config_object(json_t *obj, const char *parentkey, bool fileconf, int parent_iteration) void parse_config_object(json_t *obj, const char *parentkey, bool fileconf, int parent_iteration)
{ {
//char *err = NULL; //char *err = NULL;
const char *key; const char *key;
json_t *val; json_t *val;
json_object_foreach(obj, key, val) json_object_foreach(obj, key, val)
{ {
//process include //process include
if(!strcasecmp(key, "include")) if(!strcasecmp(key, "include"))
{ {
if(val && json_is_string(val)) if(val && json_is_string(val))
load_config(json_string_value(val), parentkey, NULL); load_config(json_string_value(val), parentkey, NULL);
} }
else else
parse_config(val, key, parentkey, fileconf, parent_iteration); parse_config(val, key, parentkey, fileconf, parent_iteration);
/* /*
{ {
if((err = parse_config(val, key, parentkey, fileconf, parent_iteration))) if((err = parse_config(val, key, parentkey, fileconf, parent_iteration)))
return err; return err;
}*/ }*/
} }
} }
//Handle parsing JSON arrays //Handle parsing JSON arrays
static char *parse_config_array(json_t *obj, char *parentkey, bool fileconf) static char *parse_config_array(json_t *obj, char *parentkey, bool fileconf)
{ {
char *err = NULL; char *err = NULL;
size_t idx; size_t idx;
json_t *val; json_t *val;
//fix parent key - remove extra "s" to match opt names (e.g. --pool-gpu-memclock not --pools-gpu-memclock) //fix parent key - remove extra "s" to match opt names (e.g. --pool-gpu-memclock not --pools-gpu-memclock)
if(!strcasecmp(parentkey, "pools") || !strcasecmp(parentkey, "profiles")) if(!strcasecmp(parentkey, "pools") || !strcasecmp(parentkey, "profiles"))
parentkey[(strlen(parentkey) - 1)] = '\0'; parentkey[(strlen(parentkey) - 1)] = '\0';
json_array_foreach(obj, idx, val) json_array_foreach(obj, idx, val)
{ {
//abort on error //abort on error
if((err = parse_config(val, "", parentkey, fileconf, idx))) if((err = parse_config(val, "", parentkey, fileconf, idx)))
return err; return err;
} }
return NULL; return NULL;
} }
//Parse JSON values from config file //Parse JSON values from config file
@ -430,7 +430,7 @@ char *parse_config(json_t *val, const char *key, const char *parentkey, bool fil
if((opt = opt_find(opt_config_table, optname)) != NULL) if((opt = opt_find(opt_config_table, optname)) != NULL)
{ {
//strings //strings
if ((opt->type & OPT_HASARG) && json_is_string(val)) if ((opt->type & OPT_HASARG) && json_is_string(val))
err = opt->cb_arg(json_string_value(val), opt->u.arg); err = opt->cb_arg(json_string_value(val), opt->u.arg);
//boolean values //boolean values
else if ((opt->type & OPT_NOARG) && json_is_true(val)) else if ((opt->type & OPT_NOARG) && json_is_true(val))
@ -445,17 +445,17 @@ char *parse_config(json_t *val, const char *key, const char *parentkey, bool fil
} }
//error processing JSON... //error processing JSON...
if(err) if(err)
{ {
/* Allow invalid values to be in configuration /* Allow invalid values to be in configuration
* file, just skipping over them provided the * file, just skipping over them provided the
* JSON is still valid after that. */ * JSON is still valid after that. */
if(fileconf) if(fileconf)
{ {
applog(LOG_WARNING, "Skipping config option %s: %s", optname+2, err); applog(LOG_WARNING, "Skipping config option %s: %s", optname+2, err);
fileconf_load = -1; fileconf_load = -1;
} }
else else
{ {
snprintf(err_buf, sizeof(err_buf), "Error parsing JSON option %s: %s", optname+2, err); snprintf(err_buf, sizeof(err_buf), "Error parsing JSON option %s: %s", optname+2, err);
return err_buf; return err_buf;
@ -467,56 +467,56 @@ char *parse_config(json_t *val, const char *key, const char *parentkey, bool fil
char *load_config(const char *arg, const char *parentkey, void __maybe_unused *unused) char *load_config(const char *arg, const char *parentkey, void __maybe_unused *unused)
{ {
json_error_t err; json_error_t err;
json_t *config; json_t *config;
//most likely useless but leaving it here for now... //most likely useless but leaving it here for now...
if(!cnfbuf) if(!cnfbuf)
cnfbuf = strdup(arg); cnfbuf = strdup(arg);
//no need to restrict the number of includes... if it causes problems, restore it later //no need to restrict the number of includes... if it causes problems, restore it later
/*if(++include_count > JSON_MAX_DEPTH) /*if(++include_count > JSON_MAX_DEPTH)
return JSON_MAX_DEPTH_ERR; return JSON_MAX_DEPTH_ERR;
*/ */
#if JANSSON_MAJOR_VERSION > 1 #if JANSSON_MAJOR_VERSION > 1
config = json_load_file(arg, 0, &err); config = json_load_file(arg, 0, &err);
#else #else
config = json_load_file(arg, &err); config = json_load_file(arg, &err);
#endif #endif
//if json root is not an object, error out //if json root is not an object, error out
if(!json_is_object(config)) if(!json_is_object(config))
{ {
set_last_json_error(JSON_LOAD_ERROR, arg, err.text); set_last_json_error(JSON_LOAD_ERROR, arg, err.text);
return last_json_error; return last_json_error;
} }
config_loaded = true; config_loaded = true;
/* Parse the config now, so we can override it. That can keep pointers /* Parse the config now, so we can override it. That can keep pointers
* so don't free config object. */ * so don't free config object. */
return parse_config(config, "", parentkey, true, -1); return parse_config(config, "", parentkey, true, -1);
} }
char *set_default_config(const char *arg) char *set_default_config(const char *arg)
{ {
opt_set_charp(arg, &default_config); opt_set_charp(arg, &default_config);
return NULL; return NULL;
} }
void load_default_config(void) void load_default_config(void)
{ {
cnfbuf = (char *)malloc(PATH_MAX); cnfbuf = (char *)malloc(PATH_MAX);
default_save_file(cnfbuf); default_save_file(cnfbuf);
if (!access(cnfbuf, R_OK)) if (!access(cnfbuf, R_OK))
load_config(cnfbuf, "", NULL); load_config(cnfbuf, "", NULL);
else { else {
free(cnfbuf); free(cnfbuf);
cnfbuf = NULL; cnfbuf = NULL;
} }
} }
/******************************************* /*******************************************
@ -526,36 +526,36 @@ void load_default_config(void)
//assign default settings from default profile if set //assign default settings from default profile if set
void load_default_profile() void load_default_profile()
{ {
struct profile *profile; struct profile *profile;
//if a default profile name is set //if a default profile name is set
if(!empty_string(default_profile.name)) if(!empty_string(default_profile.name))
{ {
//find profile and copy settings //find profile and copy settings
if((profile = get_profile(default_profile.name))) if((profile = get_profile(default_profile.name)))
{ {
default_profile.algorithm = profile->algorithm; default_profile.algorithm = profile->algorithm;
default_profile.intensity = profile->intensity; default_profile.intensity = profile->intensity;
default_profile.xintensity = profile->xintensity; default_profile.xintensity = profile->xintensity;
default_profile.rawintensity = profile->rawintensity; default_profile.rawintensity = profile->rawintensity;
default_profile.thread_concurrency = profile->thread_concurrency; default_profile.thread_concurrency = profile->thread_concurrency;
#ifdef HAVE_ADL #ifdef HAVE_ADL
default_profile.gpu_engine = profile->gpu_engine; default_profile.gpu_engine = profile->gpu_engine;
default_profile.gpu_memclock = profile->gpu_memclock; default_profile.gpu_memclock = profile->gpu_memclock;
default_profile.gpu_threads = profile->gpu_threads; default_profile.gpu_threads = profile->gpu_threads;
default_profile.gpu_fan = profile->gpu_fan; default_profile.gpu_fan = profile->gpu_fan;
#endif #endif
} }
} }
} }
//apply default settings //apply default settings
void apply_defaults() void apply_defaults()
{ {
set_algorithm(opt_algorithm, default_profile.algorithm.name); set_algorithm(opt_algorithm, default_profile.algorithm.name);
if(!empty_string(default_profile.intensity)) if(!empty_string(default_profile.intensity))
set_intensity(default_profile.intensity); set_intensity(default_profile.intensity);
if(!empty_string(default_profile.xintensity)) if(!empty_string(default_profile.xintensity))
set_xintensity(default_profile.xintensity); set_xintensity(default_profile.xintensity);
@ -584,74 +584,74 @@ void apply_defaults()
//apply profile settings to pools //apply profile settings to pools
void apply_pool_profiles() void apply_pool_profiles()
{ {
struct profile *profile; struct profile *profile;
int i; int i;
for(i=total_pools;i--;) for(i=total_pools;i--;)
{ {
//if the pool has a profile set //if the pool has a profile set
if(!empty_string(pools[i]->profile)) if(!empty_string(pools[i]->profile))
{ {
applog(LOG_DEBUG, "Loading settings from profile \"%s\" for pool %i", pools[i]->profile, pools[i]->pool_no); applog(LOG_DEBUG, "Loading settings from profile \"%s\" for pool %i", pools[i]->profile, pools[i]->pool_no);
//find profile and apply settings to the pool //find profile and apply settings to the pool
if((profile = get_profile(pools[i]->profile))) if((profile = get_profile(pools[i]->profile)))
{ {
pools[i]->algorithm = profile->algorithm; pools[i]->algorithm = profile->algorithm;
applog(LOG_DEBUG, "Pool %i Algorithm set to \"%s\"", pools[i]->pool_no, pools[i]->algorithm.name); applog(LOG_DEBUG, "Pool %i Algorithm set to \"%s\"", pools[i]->pool_no, pools[i]->algorithm.name);
if(!empty_string(profile->intensity)) if(!empty_string(profile->intensity))
{ {
pools[i]->intensity = profile->intensity; pools[i]->intensity = profile->intensity;
applog(LOG_DEBUG, "Pool %i Intensity set to \"%s\"", pools[i]->pool_no, pools[i]->intensity); applog(LOG_DEBUG, "Pool %i Intensity set to \"%s\"", pools[i]->pool_no, pools[i]->intensity);
} }
if(!empty_string(profile->xintensity)) if(!empty_string(profile->xintensity))
{ {
pools[i]->xintensity = profile->xintensity; pools[i]->xintensity = profile->xintensity;
applog(LOG_DEBUG, "Pool %i XIntensity set to \"%s\"", pools[i]->pool_no, pools[i]->xintensity); applog(LOG_DEBUG, "Pool %i XIntensity set to \"%s\"", pools[i]->pool_no, pools[i]->xintensity);
} }
if(!empty_string(profile->rawintensity)) if(!empty_string(profile->rawintensity))
{ {
pools[i]->rawintensity = profile->rawintensity; pools[i]->rawintensity = profile->rawintensity;
applog(LOG_DEBUG, "Pool %i Raw Intensity set to \"%s\"", pools[i]->pool_no, pools[i]->rawintensity); applog(LOG_DEBUG, "Pool %i Raw Intensity set to \"%s\"", pools[i]->pool_no, pools[i]->rawintensity);
} }
if(!empty_string(profile->thread_concurrency)) if(!empty_string(profile->thread_concurrency))
{ {
pools[i]->thread_concurrency = profile->thread_concurrency; pools[i]->thread_concurrency = profile->thread_concurrency;
applog(LOG_DEBUG, "Pool %i Thread Concurrency set to \"%s\"", pools[i]->pool_no, pools[i]->thread_concurrency); applog(LOG_DEBUG, "Pool %i Thread Concurrency set to \"%s\"", pools[i]->pool_no, pools[i]->thread_concurrency);
} }
#ifdef HAVE_ADL #ifdef HAVE_ADL
if(!empty_string(profile->gpu_engine)) if(!empty_string(profile->gpu_engine))
{ {
pools[i]->gpu_engine = profile->gpu_engine; pools[i]->gpu_engine = profile->gpu_engine;
applog(LOG_DEBUG, "Pool %i GPU Clock set to \"%s\"", pools[i]->pool_no, pools[i]->gpu_engine); applog(LOG_DEBUG, "Pool %i GPU Clock set to \"%s\"", pools[i]->pool_no, pools[i]->gpu_engine);
} }
if(!empty_string(profile->gpu_memclock)) if(!empty_string(profile->gpu_memclock))
{ {
pools[i]->gpu_memclock = profile->gpu_memclock; pools[i]->gpu_memclock = profile->gpu_memclock;
applog(LOG_DEBUG, "Pool %i GPU Memory clock set to \"%s\"", pools[i]->pool_no, pools[i]->gpu_memclock); applog(LOG_DEBUG, "Pool %i GPU Memory clock set to \"%s\"", pools[i]->pool_no, pools[i]->gpu_memclock);
} }
if(!empty_string(profile->gpu_threads)) if(!empty_string(profile->gpu_threads))
{ {
pools[i]->gpu_threads = profile->gpu_threads; pools[i]->gpu_threads = profile->gpu_threads;
applog(LOG_DEBUG, "Pool %i GPU Threads set to \"%s\"", pools[i]->pool_no, pools[i]->gpu_threads); applog(LOG_DEBUG, "Pool %i GPU Threads set to \"%s\"", pools[i]->pool_no, pools[i]->gpu_threads);
} }
if(!empty_string(profile->gpu_fan)) if(!empty_string(profile->gpu_fan))
{ {
pools[i]->gpu_fan = profile->gpu_fan; pools[i]->gpu_fan = profile->gpu_fan;
applog(LOG_DEBUG, "Pool %i GPU Fan set to \"%s\"", pools[i]->pool_no, pools[i]->gpu_fan); applog(LOG_DEBUG, "Pool %i GPU Fan set to \"%s\"", pools[i]->pool_no, pools[i]->gpu_fan);
} }
#endif #endif
} }
else else
applog(LOG_DEBUG, "Profile load failed for pool %i: profile %s not found.", pools[i]->pool_no, pools[i]->profile); applog(LOG_DEBUG, "Profile load failed for pool %i: profile %s not found.", pools[i]->pool_no, pools[i]->profile);
} }
} }
} }

30
config_parser.h
Unescape View File

@ -13,18 +13,18 @@
//profile structure //profile structure
struct profile { struct profile {
int profile_no; int profile_no;
char *name; char *name;
algorithm_t algorithm; algorithm_t algorithm;
const char *intensity; const char *intensity;
const char *xintensity; const char *xintensity;
const char *rawintensity; const char *rawintensity;
const char *thread_concurrency; const char *thread_concurrency;
const char *gpu_engine; const char *gpu_engine;
const char *gpu_memclock; const char *gpu_memclock;
const char *gpu_threads; const char *gpu_threads;
const char *gpu_fan; const char *gpu_fan;
}; };
/* globals needed outside */ /* globals needed outside */
@ -44,9 +44,9 @@ extern char *set_default_xintensity(const char *arg);
extern char *set_default_rawintensity(const char *arg); extern char *set_default_rawintensity(const char *arg);
extern char *set_default_thread_concurrency(const char *arg); extern char *set_default_thread_concurrency(const char *arg);
#ifdef HAVE_ADL #ifdef HAVE_ADL
extern char *set_default_gpu_engine(const char *arg); extern char *set_default_gpu_engine(const char *arg);
extern char *set_default_gpu_memclock(const char *arg); extern char *set_default_gpu_memclock(const char *arg);
extern char *set_default_gpu_threads(const char *arg); extern char *set_default_gpu_threads(const char *arg);
extern char *set_default_gpu_fan(const char *arg); extern char *set_default_gpu_fan(const char *arg);
#endif #endif
extern char *set_default_profile(char *arg); extern char *set_default_profile(char *arg);
@ -58,7 +58,7 @@ extern char *set_profile_xintensity(const char *arg);
extern char *set_profile_rawintensity(const char *arg); extern char *set_profile_rawintensity(const char *arg);
extern char *set_profile_thread_concurrency(const char *arg); extern char *set_profile_thread_concurrency(const char *arg);
#ifdef HAVE_ADL #ifdef HAVE_ADL
extern char *set_profile_gpu_engine(const char *arg); extern char *set_profile_gpu_engine(const char *arg);
extern char *set_profile_gpu_memclock(const char *arg); extern char *set_profile_gpu_memclock(const char *arg);
extern char *set_profile_gpu_threads(const char *arg); extern char *set_profile_gpu_threads(const char *arg);
extern char *set_profile_gpu_fan(const char *arg); extern char *set_profile_gpu_fan(const char *arg);

Write Preview
Loading…
Cancel
Save