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

Fix various harmless warnings.

Browse Source
This commit is contained in:
Con Kolivas 2012-01-29 21:06:17 +11:00
parent a8e46a074e
commit a4b67f030f
5 changed files with 38 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
adl.c
View File

@ -936,7 +936,7 @@ static int set_powertune(int gpu, int iPercentage)
return ret; return ret;
} }
static void fan_autotune(int gpu, int temp, int fanpercent, bool *fan_optimal) static void fan_autotune(int gpu, int temp, int fanpercent, __maybe_unused bool *fan_optimal)
{ {
struct cgpu_info *cgpu = &gpus[gpu]; struct cgpu_info *cgpu = &gpus[gpu];
struct gpu_adl *ga = &cgpu->adl; struct gpu_adl *ga = &cgpu->adl;
@ -1244,7 +1244,7 @@ updated:
goto updated; goto updated;
} }
void clear_adl(nDevs) void clear_adl(int nDevs)
{ {
struct gpu_adl *ga; struct gpu_adl *ga;
int i; int i;

43
main.c
View File

@ -181,7 +181,7 @@ int opt_log_interval = 5;
bool opt_log_output = false; bool opt_log_output = false;
static int opt_queue = 1; static int opt_queue = 1;
int opt_vectors; int opt_vectors;
int opt_worksize; unsigned int opt_worksize;
int opt_scantime = 60; int opt_scantime = 60;
int opt_expiry = 120; int opt_expiry = 120;
int opt_bench_algo = -1; int opt_bench_algo = -1;
@ -997,15 +997,18 @@ static char *set_float_0_to_99(const char *arg, float *f)
return NULL; return NULL;
} }
#ifdef USE_BITFORCE
static char *add_serial(char *arg) static char *add_serial(char *arg)
{ {
string_elist_add(arg, &scan_devices); string_elist_add(arg, &scan_devices);
return NULL; return NULL;
} }
#endif
static char *set_devices(char *arg) static char *set_devices(char *arg)
{ {
int i = strtol(arg, &arg, 0); int i = strtol(arg, &arg, 0);
if (*arg) { if (*arg) {
if (*arg == '?') { if (*arg == '?') {
devices_enabled = -1; devices_enabled = -1;
@ -1014,7 +1017,7 @@ static char *set_devices(char *arg)
return "Invalid device number"; return "Invalid device number";
} }
if (i < 0 || i >= (sizeof(devices_enabled) * 8) - 1) if (i < 0 || i >= (int)(sizeof(devices_enabled) * 8) - 1)
return "Invalid device number"; return "Invalid device number";
devices_enabled |= 1 << i; devices_enabled |= 1 << i;
return NULL; return NULL;
@ -1803,7 +1806,7 @@ static char *parse_config(json_t *config, bool fileconf)
return NULL; return NULL;
} }
static char *load_config(const char *arg, void *unused) static char *load_config(const char *arg, __maybe_unused void *unused)
{ {
json_error_t err; json_error_t err;
json_t *config; json_t *config;
@ -2580,7 +2583,7 @@ static void print_summary(void);
void kill_work(void) void kill_work(void)
{ {
struct thr_info *thr; struct thr_info *thr;
unsigned int i; int i;
disable_curses(); disable_curses();
applog(LOG_INFO, "Received kill message"); applog(LOG_INFO, "Received kill message");
@ -3773,7 +3776,7 @@ static void manage_gpu(void)
} }
#endif #endif
static void *input_thread(void *userdata) static void *input_thread(__maybe_unused void *userdata)
{ {
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
@ -4159,7 +4162,8 @@ static void roll_work(struct work *work)
/* Recycle the work at a higher starting res_nonce if we know the thread we're /* Recycle the work at a higher starting res_nonce if we know the thread we're
* giving it to will not finish scanning it. We keep the master copy to be * giving it to will not finish scanning it. We keep the master copy to be
* recycled more rapidly and discard the clone to avoid repeating work */ * recycled more rapidly and discard the clone to avoid repeating work */
static bool divide_work(struct timeval *now, struct work *work, uint32_t hash_div) static bool divide_work(__maybe_unused struct timeval *now, struct work *work,
__maybe_unused uint32_t hash_div)
{ {
if (can_roll(work) && should_roll(work)) { if (can_roll(work) && should_roll(work)) {
roll_work(work); roll_work(work);
@ -4194,7 +4198,7 @@ static bool get_work(struct work *work, bool requested, struct thr_info *thr,
const int thr_id, uint32_t hash_div) const int thr_id, uint32_t hash_div)
{ {
bool newreq = false, ret = false; bool newreq = false, ret = false;
struct timespec abstime = {}; struct timespec abstime;
struct timeval now; struct timeval now;
struct work *work_heap; struct work *work_heap;
struct pool *pool; struct pool *pool;
@ -4363,7 +4367,7 @@ bool submit_nonce(struct thr_info *thr, struct work *work, uint32_t nonce)
return submit_work_sync(thr, work); return submit_work_sync(thr, work);
} }
static inline bool abandon_work(int thr_id, struct work *work, struct timeval *wdiff, uint64_t hashes) static inline bool abandon_work(struct work *work, struct timeval *wdiff, uint64_t hashes)
{ {
if (wdiff->tv_sec > opt_scantime || if (wdiff->tv_sec > opt_scantime ||
work->blk.nonce >= MAXTHREADS - hashes || work->blk.nonce >= MAXTHREADS - hashes ||
@ -4382,7 +4386,7 @@ static void *miner_thread(void *userdata)
/* Try to cycle approximately 5 times before each log update */ /* Try to cycle approximately 5 times before each log update */
const unsigned long def_cycle = opt_log_interval / 5 ? : 1; const unsigned long def_cycle = opt_log_interval / 5 ? : 1;
unsigned long cycle; time_t cycle;
struct timeval tv_start, tv_end, tv_workstart, tv_lastupdate; struct timeval tv_start, tv_end, tv_workstart, tv_lastupdate;
struct timeval diff, sdiff, wdiff; struct timeval diff, sdiff, wdiff;
uint32_t max_nonce = api->can_limit_work ? api->can_limit_work(mythr) : 0xffffffff; uint32_t max_nonce = api->can_limit_work ? api->can_limit_work(mythr) : 0xffffffff;
@ -4418,7 +4422,7 @@ static void *miner_thread(void *userdata)
cycle = (can_roll(work) && should_roll(work)) ? 1 : def_cycle; cycle = (can_roll(work) && should_roll(work)) ? 1 : def_cycle;
gettimeofday(&tv_workstart, NULL); gettimeofday(&tv_workstart, NULL);
work->blk.nonce = 0; work->blk.nonce = 0;
if (api->prepare_work && !api->prepare_work(mythr, work)) { if (api->prepare_work && !api->prepare_work(work)) {
applog(LOG_ERR, "work prepare failed, exiting " applog(LOG_ERR, "work prepare failed, exiting "
"mining thread %d", thr_id); "mining thread %d", thr_id);
break; break;
@ -4500,7 +4504,7 @@ static void *miner_thread(void *userdata)
if (can_roll(work) && should_roll(work)) if (can_roll(work) && should_roll(work))
roll_work(work); roll_work(work);
} while (!abandon_work(thr_id, work, &wdiff, hashes)); } while (!abandon_work(work, &wdiff, hashes));
} }
out: out:
@ -4565,7 +4569,8 @@ static cl_int queue_phatk_kernel(_clState *clState, dev_blk_ctx *blk)
cl_uint vwidth = clState->preferred_vwidth; cl_uint vwidth = clState->preferred_vwidth;
cl_kernel *kernel = &clState->kernel; cl_kernel *kernel = &clState->kernel;
cl_int status = 0; cl_int status = 0;
int i, num = 0; unsigned int i;
int num = 0;
uint *nonces; uint *nonces;
status |= clSetKernelArg(*kernel, num++, sizeof(uint), (void *)&blk->ctx_a); status |= clSetKernelArg(*kernel, num++, sizeof(uint), (void *)&blk->ctx_a);
@ -4906,7 +4911,7 @@ void reinit_device(struct cgpu_info *cgpu)
/* Makes sure the hashmeter keeps going even if mining threads stall, updates /* Makes sure the hashmeter keeps going even if mining threads stall, updates
* the screen at regular intervals, and restarts threads if they appear to have * the screen at regular intervals, and restarts threads if they appear to have
* died. */ * died. */
static void *watchdog_thread(void *userdata) static void *watchdog_thread(__maybe_unused void *userdata)
{ {
const unsigned int interval = 3; const unsigned int interval = 3;
static struct timeval rotate_tv; static struct timeval rotate_tv;
@ -5709,13 +5714,14 @@ static void opencl_free_work(struct thr_info *thr, struct work *work)
} }
} }
static bool opencl_prepare_work(struct thr_info *thr, struct work *work) static bool opencl_prepare_work(struct work *work)
{ {
precalc_hash(&work->blk, (uint32_t *)(work->midstate), (uint32_t *)(work->data + 64)); precalc_hash(&work->blk, (uint32_t *)(work->midstate), (uint32_t *)(work->data + 64));
return true; return true;
} }
static uint64_t opencl_scanhash(struct thr_info *thr, struct work *work, uint64_t max_nonce) static uint64_t opencl_scanhash(struct thr_info *thr, struct work *work,
__maybe_unused uint64_t max_nonce)
{ {
const int thr_id = thr->id; const int thr_id = thr->id;
struct opencl_thread_data *thrdata = thr->cgpu_data; struct opencl_thread_data *thrdata = thr->cgpu_data;
@ -5855,12 +5861,13 @@ void enable_device(struct cgpu_info *cgpu)
int main (int argc, char *argv[]) int main (int argc, char *argv[])
{ {
unsigned int i, pools_active = 0; unsigned pools_active = 0;
unsigned int j, k;
struct block *block, *tmpblock; struct block *block, *tmpblock;
struct work *work, *tmpwork; struct work *work, *tmpwork;
struct sigaction handler; struct sigaction handler;
struct thr_info *thr; struct thr_info *thr;
unsigned int k;
int i, j;
/* This dangerous functions tramples random dynamically allocated /* This dangerous functions tramples random dynamically allocated
* variables so do it before anything at all */ * variables so do it before anything at all */
@ -5999,7 +6006,7 @@ int main (int argc, char *argv[])
mining_threads = 0; mining_threads = 0;
gpu_threads = 0; gpu_threads = 0;
if (devices_enabled) { if (devices_enabled) {
for (i = 0; i < (sizeof(devices_enabled) * 8) - 1; ++i) { for (i = 0; i < (int)(sizeof(devices_enabled) * 8) - 1; ++i) {
if (devices_enabled & (1 << i)) { if (devices_enabled & (1 << i)) {
if (i >= total_devices) if (i >= total_devices)
quit (1, "Command line options set a device that doesn't exist"); quit (1, "Command line options set a device that doesn't exist");

3
miner.h
View File

@ -147,6 +147,7 @@ enum {
#define unlikely(expr) (expr) #define unlikely(expr) (expr)
#define likely(expr) (expr) #define likely(expr) (expr)
#endif #endif
#define __maybe_unused __attribute__((unused))
#if defined(__i386__) #if defined(__i386__)
#define WANT_CRYPTOPP_ASM32 #define WANT_CRYPTOPP_ASM32
@ -250,7 +251,7 @@ struct device_api {
uint64_t (*can_limit_work)(struct thr_info*); uint64_t (*can_limit_work)(struct thr_info*);
bool (*thread_init)(struct thr_info*); bool (*thread_init)(struct thr_info*);
void (*free_work)(struct thr_info*, struct work*); void (*free_work)(struct thr_info*, struct work*);
bool (*prepare_work)(struct thr_info*, struct work*); bool (*prepare_work)(struct work*);
uint64_t (*scanhash)(struct thr_info*, struct work*, uint64_t); uint64_t (*scanhash)(struct thr_info*, struct work*, uint64_t);
void (*thread_shutdown)(struct thr_info*); void (*thread_shutdown)(struct thr_info*);
}; };

2
ocl.c
View File

@ -28,7 +28,7 @@
#include "ocl.h" #include "ocl.h"
extern int opt_vectors; extern int opt_vectors;
extern int opt_worksize; extern unsigned int opt_worksize;
char *file_contents(const char *filename, int *length) char *file_contents(const char *filename, int *length)
{ {

16
util.c
View File

@ -78,7 +78,7 @@ void vapplog(int prio, const char *fmt, va_list ap)
else if (opt_log_output || prio <= LOG_NOTICE) { else if (opt_log_output || prio <= LOG_NOTICE) {
char *f; char *f;
int len; int len;
struct timeval tv = { }; struct timeval tv;
struct tm tm; struct tm tm;
gettimeofday(&tv, NULL); gettimeofday(&tv, NULL);
@ -163,7 +163,7 @@ static size_t upload_data_cb(void *ptr, size_t size, size_t nmemb,
void *user_data) void *user_data)
{ {
struct upload_buffer *ub = user_data; struct upload_buffer *ub = user_data;
int len = size * nmemb; unsigned int len = size * nmemb;
if (len > ub->len) if (len > ub->len)
len = ub->len; len = ub->len;
@ -239,7 +239,7 @@ out:
} }
#ifdef CURL_HAS_SOCKOPT #ifdef CURL_HAS_SOCKOPT
int json_rpc_call_sockopt_cb(void *userdata, curl_socket_t fd, curlsocktype purpose) int json_rpc_call_sockopt_cb(__maybe_unused void *userdata, curl_socket_t fd, __maybe_unused curlsocktype purpose)
{ {
int keepalive = 1; int keepalive = 1;
int tcp_keepcnt = 5; int tcp_keepcnt = 5;
@ -309,14 +309,14 @@ json_t *json_rpc_call(CURL *curl, const char *url,
{ {
json_t *val, *err_val, *res_val; json_t *val, *err_val, *res_val;
int rc; int rc;
struct data_buffer all_data = { }; struct data_buffer all_data;
struct upload_buffer upload_data; struct upload_buffer upload_data;
json_error_t err = { }; json_error_t err;
struct curl_slist *headers = NULL; struct curl_slist *headers = NULL;
char len_hdr[64], user_agent_hdr[128]; char len_hdr[64], user_agent_hdr[128];
char curl_err_str[CURL_ERROR_SIZE]; char curl_err_str[CURL_ERROR_SIZE];
long timeout = longpoll ? (60 * 60) : 60; long timeout = longpoll ? (60 * 60) : 60;
struct header_info hi = { }; struct header_info hi;
bool probing = false; bool probing = false;
/* it is assumed that 'curl' is freshly [re]initialized at this pt */ /* it is assumed that 'curl' is freshly [re]initialized at this pt */
@ -478,7 +478,7 @@ err_out:
char *bin2hex(const unsigned char *p, size_t len) char *bin2hex(const unsigned char *p, size_t len)
{ {
int i; unsigned int i;
char *s = malloc((len * 2) + 1); char *s = malloc((len * 2) + 1);
if (!s) if (!s)
return NULL; return NULL;
@ -730,7 +730,7 @@ void thr_info_cancel(struct thr_info *thr)
bool get_dondata(char **url, char **userpass) bool get_dondata(char **url, char **userpass)
{ {
struct data_buffer all_data = { }; struct data_buffer all_data ;
char curl_err_str[CURL_ERROR_SIZE]; char curl_err_str[CURL_ERROR_SIZE];
CURL *curl = curl_easy_init(); CURL *curl = curl_easy_init();
int rc; int rc;