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

Fixed whitespaces

Browse Source 
Cleaned up whitespaces in code
This commit is contained in:
Yann St. Arnaud 2014-06-15 12:32:52 -04:00 committed by Noel Maersk
parent 9faa8fa59f
commit 03379f9f51
2 changed files with 317 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

604
config_parser.c
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)
{
default_profile.gpu_fan = arg;
return NULL;
}
char *set_default_gpu_fan(const char *arg)
{
default_profile.gpu_fan = arg;
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++)
{
/* We don't handle subtables. */
assert(!(opt->type & OPT_SUBTABLE));
if(!opt->names) for(opt = tbl;opt->type != OPT_END;opt++)
continue; {
/* We don't handle subtables. */
assert(!(opt->type & OPT_SUBTABLE));
/* Pull apart the option name(s). */ if(!opt->names)
name = strdup(opt->names); continue;
for(p = strtok(name, "|");p;p = strtok(NULL, "|"))
{ /* Pull apart the option name(s). */
/* Ignore short options. */ name = strdup(opt->names);
if(p[1] != '-') for(p = strtok(name, "|");p;p = strtok(NULL, "|"))
continue; {
/* Ignore short options. */
//if this is the opt we're looking for, return it... if(p[1] != '-')
if(!strcasecmp(optname, p)) continue;
{
free(name); //if this is the opt we're looking for, return it...
return opt; if(!strcasecmp(optname, p))
} {
} free(name);
free(name); return opt;
} }
}
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
/*if(++include_count > JSON_MAX_DEPTH)
return JSON_MAX_DEPTH_ERR;
*/
//no need to restrict the number of includes... if it causes problems, restore it later
/*if(++include_count > JSON_MAX_DEPTH)
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
if((profile = get_profile(pools[i]->profile)))
{
pools[i]->algorithm = profile->algorithm;
applog(LOG_DEBUG, "Pool %i Algorithm set to \"%s\"", pools[i]->pool_no, pools[i]->algorithm.name);
if(!empty_string(profile->intensity))
{
pools[i]->intensity = profile->intensity;
applog(LOG_DEBUG, "Pool %i Intensity set to \"%s\"", pools[i]->pool_no, pools[i]->intensity);
}
if(!empty_string(profile->xintensity))
{
pools[i]->xintensity = profile->xintensity;
applog(LOG_DEBUG, "Pool %i XIntensity set to \"%s\"", pools[i]->pool_no, pools[i]->xintensity);
}
if(!empty_string(profile->rawintensity)) //find profile and apply settings to the pool
{ if((profile = get_profile(pools[i]->profile)))
pools[i]->rawintensity = profile->rawintensity; {
applog(LOG_DEBUG, "Pool %i Raw Intensity set to \"%s\"", pools[i]->pool_no, pools[i]->rawintensity); pools[i]->algorithm = profile->algorithm;
} applog(LOG_DEBUG, "Pool %i Algorithm set to \"%s\"", pools[i]->pool_no, pools[i]->algorithm.name);
if(!empty_string(profile->thread_concurrency)) if(!empty_string(profile->intensity))
{ {
pools[i]->thread_concurrency = profile->thread_concurrency; pools[i]->intensity = profile->intensity;
applog(LOG_DEBUG, "Pool %i Thread Concurrency set to \"%s\"", pools[i]->pool_no, pools[i]->thread_concurrency); applog(LOG_DEBUG, "Pool %i Intensity set to \"%s\"", pools[i]->pool_no, pools[i]->intensity);
} }
if(!empty_string(profile->xintensity))
{
pools[i]->xintensity = profile->xintensity;
applog(LOG_DEBUG, "Pool %i XIntensity set to \"%s\"", pools[i]->pool_no, pools[i]->xintensity);
}
if(!empty_string(profile->rawintensity))
{
pools[i]->rawintensity = profile->rawintensity;
applog(LOG_DEBUG, "Pool %i Raw Intensity set to \"%s\"", pools[i]->pool_no, pools[i]->rawintensity);
}
if(!empty_string(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);
}
#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
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);