/* * Copyright 2010 Jeff Garzik * Copyright 2012-2014 pooler * Copyright 2014-2015 tpruvot * * 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 * Software Foundation; either version 2 of the License, or (at your option) * any later version. See COPYING for more details. */ #include "cpuminer-config.h" #include #include #include #include #include #include #include #include #include #include #include #include #ifdef WIN32 #include #include #else #include #include #if HAVE_SYS_SYSCTL_H #include #if HAVE_SYS_PARAM_H #include #endif #include #endif #endif #include "miner.h" #include "algos.h" #include #ifdef WIN32 #include #pragma comment(lib, "winmm.lib") #include "compat/winansi.h" BOOL WINAPI ConsoleHandler(DWORD); #endif #define PROGRAM_NAME "ccminer" #define LP_SCANTIME 60 #define HEAVYCOIN_BLKHDR_SZ 84 #define MNR_BLKHDR_SZ 80 #include "nvml.h" #ifdef USE_WRAPNVML nvml_handle *hnvml = NULL; #endif enum workio_commands { WC_GET_WORK, WC_SUBMIT_WORK, WC_ABORT, }; struct workio_cmd { enum workio_commands cmd; struct thr_info *thr; union { struct work *work; } u; int pooln; }; bool opt_debug = false; bool opt_debug_diff = false; bool opt_debug_threads = false; bool opt_protocol = false; bool opt_benchmark = false; bool opt_showdiff = false; // todo: limit use of these flags, // prefer the pools[] attributes bool want_longpoll = true; bool have_longpoll = false; bool want_stratum = true; bool have_stratum = false; bool allow_gbt = true; bool allow_mininginfo = true; bool check_dups = false; bool check_stratum_jobs = false; static bool submit_old = false; bool use_syslog = false; bool use_colors = true; int use_pok = 0; static bool opt_background = false; bool opt_quiet = false; static int opt_retries = -1; static int opt_fail_pause = 30; int opt_time_limit = -1; time_t firstwork_time = 0; int opt_timeout = 300; // curl int opt_scantime = 10; static json_t *opt_config; static const bool opt_time = true; volatile enum sha_algos opt_algo = ALGO_AUTO; int opt_n_threads = 0; int gpu_threads = 1; int64_t opt_affinity = -1L; int opt_priority = 0; static double opt_difficulty = 1.; bool opt_extranonce = true; bool opt_trust_pool = false; uint16_t opt_vote = 9999; int num_cpus; int active_gpus; char * device_name[MAX_GPUS]; short device_map[MAX_GPUS] = { 0 }; long device_sm[MAX_GPUS] = { 0 }; uint32_t gpus_intensity[MAX_GPUS] = { 0 }; uint32_t device_gpu_clocks[MAX_GPUS] = { 0 }; uint32_t device_mem_clocks[MAX_GPUS] = { 0 }; uint32_t device_plimit[MAX_GPUS] = { 0 }; int8_t device_pstate[MAX_GPUS] = { -1 }; int opt_cudaschedule = -1; static bool opt_keep_clocks = false; // un-linked to cmdline scrypt options (useless) int device_batchsize[MAX_GPUS] = { 0 }; int device_texturecache[MAX_GPUS] = { 0 }; int device_singlememory[MAX_GPUS] = { 0 }; // implemented scrypt options int parallel = 2; // All should be made on GPU char *device_config[MAX_GPUS] = { 0 }; int device_backoff[MAX_GPUS] = { 0 }; int device_lookup_gap[MAX_GPUS] = { 0 }; int device_interactive[MAX_GPUS] = { 0 }; int opt_nfactor = 0; bool opt_autotune = true; char *jane_params = NULL; // pools (failover/getwork infos) struct pool_infos pools[MAX_POOLS] = { 0 }; int num_pools = 1; volatile int cur_pooln = 0; bool opt_pool_failover = true; volatile bool pool_on_hold = false; volatile bool pool_is_switching = false; volatile int pool_switch_count = 0; bool conditional_pool_rotate = false; // current connection char *rpc_user = NULL; char *rpc_pass; char *rpc_url; char *short_url = NULL; struct stratum_ctx stratum = { 0 }; pthread_mutex_t stratum_sock_lock; pthread_mutex_t stratum_work_lock; char *opt_cert; char *opt_proxy; long opt_proxy_type; struct thr_info *thr_info = NULL; static int work_thr_id; struct thr_api *thr_api; int longpoll_thr_id = -1; int stratum_thr_id = -1; int api_thr_id = -1; bool stratum_need_reset = false; volatile bool abort_flag = false; struct work_restart *work_restart = NULL; static int app_exit_code = EXIT_CODE_OK; pthread_mutex_t applog_lock; pthread_mutex_t stats_lock; double thr_hashrates[MAX_GPUS] = { 0 }; uint64_t global_hashrate = 0; double stratum_diff = 0.0; double net_diff = 0; uint64_t net_hashrate = 0; uint64_t net_blocks = 0; // conditional mining uint8_t conditional_state[MAX_GPUS] = { 0 }; double opt_max_temp = 0.0; double opt_max_diff = -1.; double opt_max_rate = -1.; double opt_resume_temp = 0.; double opt_resume_diff = 0.; double opt_resume_rate = -1.; int opt_statsavg = 30; // strdup on char* to allow a common free() if used static char* opt_syslog_pfx = strdup(PROGRAM_NAME); char *opt_api_allow = strdup("127.0.0.1"); /* 0.0.0.0 for all ips */ int opt_api_remote = 0; int opt_api_listen = 4068; /* 0 to disable */ bool opt_stratum_stats = false; static char const usage[] = "\ Usage: " PROGRAM_NAME " [OPTIONS]\n\ Options:\n\ -a, --algo=ALGO specify the hash algorithm to use\n\ blake Blake 256 (SFR)\n\ blake2s Blake2-S 256 (NEVA)\n\ blakecoin Fast Blake 256 (8 rounds)\n\ bmw BMW 256\n\ c11/flax X11 variant\n\ decred Decred Blake256\n\ deep Deepcoin\n\ dmd-gr Diamond-Groestl\n\ fresh Freshcoin (shavite 80)\n\ fugue256 Fuguecoin\n\ groestl Groestlcoin\n\ heavy Heavycoin\n\ jackpot Jackpot\n\ keccak Keccak-256 (Maxcoin)\n\ luffa Joincoin\n\ lyra2 LyraBar\n\ lyra2v2 VertCoin\n\ mjollnir Mjollnircoin\n\ myr-gr Myriad-Groestl\n\ neoscrypt FeatherCoin, Phoenix, UFO...\n\ nist5 NIST5 (TalkCoin)\n\ penta Pentablake hash (5x Blake 512)\n\ quark Quark\n\ qubit Qubit\n\ sib Sibcoin (X11+Streebog)\n\ scrypt Scrypt\n\ scrypt-jane Scrypt-jane Chacha\n\ skein Skein SHA2 (Skeincoin)\n\ skein2 Double Skein (Woodcoin)\n\ s3 S3 (1Coin)\n\ x11 X11 (DarkCoin)\n\ x13 X13 (MaruCoin)\n\ x14 X14\n\ x15 X15\n\ x17 X17\n\ vanilla Blake256-8 (VNL)\n\ whirlcoin Old Whirlcoin (Whirlpool algo)\n\ whirlpool Whirlpool algo\n\ zr5 ZR5 (ZiftrCoin)\n\ -d, --devices Comma separated list of CUDA devices to use.\n\ Device IDs start counting from 0! Alternatively takes\n\ string names of your cards like gtx780ti or gt640#2\n\ (matching 2nd gt640 in the PC)\n\ -i --intensity=N[,N] GPU intensity 8.0-25.0 (default: auto) \n\ Decimals are allowed for fine tuning \n\ --cuda-schedule Set device threads scheduling mode (default: auto)\n\ -f, --diff-factor Divide difficulty by this factor (default 1.0) \n\ -m, --diff-multiplier Multiply difficulty by this value (default 1.0) \n\ --vote=VOTE vote (for decred and HeavyCoin)\n\ --trust-pool trust the max block reward vote (maxvote) sent by the pool\n\ -o, --url=URL URL of mining server\n\ -O, --userpass=U:P username:password pair for mining server\n\ -u, --user=USERNAME username for mining server\n\ -p, --pass=PASSWORD password for mining server\n\ --cert=FILE certificate for mining server using SSL\n\ -x, --proxy=[PROTOCOL://]HOST[:PORT] connect through a proxy\n\ -t, --threads=N number of miner threads (default: number of nVidia GPUs)\n\ -r, --retries=N number of times to retry if a network call fails\n\ (default: retry indefinitely)\n\ -R, --retry-pause=N time to pause between retries, in seconds (default: 30)\n\ --time-limit maximum time [s] to mine before exiting the program.\n\ -T, --timeout=N network timeout, in seconds (default: 300)\n\ -s, --scantime=N upper bound on time spent scanning current work when\n\ long polling is unavailable, in seconds (default: 10)\n\ -n, --ndevs list cuda devices\n\ -N, --statsavg number of samples used to compute hashrate (default: 30)\n\ --no-gbt disable getblocktemplate support (height check in solo)\n\ --no-longpoll disable X-Long-Polling support\n\ --no-stratum disable X-Stratum support\n\ --no-extranonce disable extranonce subscribe on stratum\n\ -q, --quiet disable per-thread hashmeter output\n\ --no-color disable colored output\n\ -D, --debug enable debug output\n\ -P, --protocol-dump verbose dump of protocol-level activities\n\ --cpu-affinity set process affinity to cpu core(s), mask 0x3 for cores 0 and 1\n\ --cpu-priority set process priority (default: 3) 0 idle, 2 normal to 5 highest\n\ -b, --api-bind=port IP:port for the miner API (default: 127.0.0.1:4068), 0 disabled\n\ --api-remote Allow remote control, like pool switching\n\ --max-temp=N Only mine if gpu temp is less than specified value\n\ --max-rate=N[KMG] Only mine if net hashrate is less than specified value\n\ --max-diff=N Only mine if net difficulty is less than specified value\n\ Can be tuned with --resume-diff=N to set a resume value\n" #if defined(USE_WRAPNVML) && (defined(__linux) || defined(_WIN64)) /* via nvml */ "\ --mem-clock=3505 Set the gpu memory max clock (346.72+ driver)\n\ --gpu-clock=1150 Set the gpu engine max clock (346.72+ driver)\n\ --pstate=0[,2] Set the gpu power state (352.21+ driver)\n\ --plimit=100W Set the gpu power limit (352.21+ driver)\n" #endif #ifdef HAVE_SYSLOG_H "\ -S, --syslog use system log for output messages\n\ --syslog-prefix=... allow to change syslog tool name\n" #endif "\ --show-diff display submitted block and net difficulty\n\ -B, --background run the miner in the background\n\ --benchmark run in offline benchmark mode\n\ --cputest debug hashes from cpu algorithms\n\ -c, --config=FILE load a JSON-format configuration file\n\ -V, --version display version information and exit\n\ -h, --help display this help text and exit\n\ "; static char const short_options[] = #ifdef HAVE_SYSLOG_H "S" #endif "a:Bc:i:Dhp:Px:f:m:nqr:R:s:t:T:o:u:O:Vd:N:b:l:L:"; struct option options[] = { { "algo", 1, NULL, 'a' }, { "api-bind", 1, NULL, 'b' }, { "api-remote", 0, NULL, 1030 }, { "background", 0, NULL, 'B' }, { "benchmark", 0, NULL, 1005 }, { "cert", 1, NULL, 1001 }, { "config", 1, NULL, 'c' }, { "cputest", 0, NULL, 1006 }, { "cpu-affinity", 1, NULL, 1020 }, { "cpu-priority", 1, NULL, 1021 }, { "cuda-schedule", 1, NULL, 1025 }, { "debug", 0, NULL, 'D' }, { "help", 0, NULL, 'h' }, { "intensity", 1, NULL, 'i' }, { "ndevs", 0, NULL, 'n' }, { "no-color", 0, NULL, 1002 }, { "no-extranonce", 0, NULL, 1012 }, { "no-gbt", 0, NULL, 1011 }, { "no-longpoll", 0, NULL, 1003 }, { "no-stratum", 0, NULL, 1007 }, { "no-autotune", 0, NULL, 1004 }, // scrypt { "interactive", 1, NULL, 1050 }, // scrypt { "launch-config", 1, NULL, 'l' }, // scrypt { "lookup-gap", 1, NULL, 'L' }, // scrypt { "texture-cache", 1, NULL, 1051 },// scrypt { "max-temp", 1, NULL, 1060 }, { "max-diff", 1, NULL, 1061 }, { "max-rate", 1, NULL, 1062 }, { "resume-diff", 1, NULL, 1063 }, { "resume-rate", 1, NULL, 1064 }, { "resume-temp", 1, NULL, 1065 }, { "pass", 1, NULL, 'p' }, { "pool-name", 1, NULL, 1100 }, // pool { "pool-algo", 1, NULL, 1101 }, // pool { "pool-scantime", 1, NULL, 1102 }, // pool { "pool-time-limit", 1, NULL, 1108 }, { "pool-max-diff", 1, NULL, 1161 }, // pool { "pool-max-rate", 1, NULL, 1162 }, // pool { "pool-disabled", 1, NULL, 1199 }, // pool { "protocol-dump", 0, NULL, 'P' }, { "proxy", 1, NULL, 'x' }, { "quiet", 0, NULL, 'q' }, { "retries", 1, NULL, 'r' }, { "retry-pause", 1, NULL, 'R' }, { "scantime", 1, NULL, 's' }, { "show-diff", 0, NULL, 1013 }, { "statsavg", 1, NULL, 'N' }, { "gpu-clock", 1, NULL, 1070 }, { "mem-clock", 1, NULL, 1071 }, { "pstate", 1, NULL, 1072 }, { "plimit", 1, NULL, 1073 }, { "keep-clocks", 0, NULL, 1074 }, #ifdef HAVE_SYSLOG_H { "syslog", 0, NULL, 'S' }, { "syslog-prefix", 1, NULL, 1018 }, #endif { "time-limit", 1, NULL, 1008 }, { "threads", 1, NULL, 't' }, { "vote", 1, NULL, 1022 }, { "trust-pool", 0, NULL, 1023 }, { "timeout", 1, NULL, 'T' }, { "url", 1, NULL, 'o' }, { "user", 1, NULL, 'u' }, { "userpass", 1, NULL, 'O' }, { "version", 0, NULL, 'V' }, { "devices", 1, NULL, 'd' }, { "diff-multiplier", 1, NULL, 'm' }, { "diff-factor", 1, NULL, 'f' }, { "diff", 1, NULL, 'f' }, // compat { 0, 0, 0, 0 } }; static char const scrypt_usage[] = "\n\ Scrypt specific options:\n\ -l, --launch-config gives the launch configuration for each kernel\n\ in a comma separated list, one per device.\n\ -L, --lookup-gap Divides the per-hash memory requirement by this factor\n\ by storing only every N'th value in the scratchpad.\n\ Default is 1.\n\ --interactive comma separated list of flags (0/1) specifying\n\ which of the CUDA device you need to run at inter-\n\ active frame rates (because it drives a display).\n\ --texture-cache comma separated list of flags (0/1/2) specifying\n\ which of the CUDA devices shall use the texture\n\ cache for mining. Kepler devices may profit.\n\ --no-autotune disable auto-tuning of kernel launch parameters\n\ "; struct work _ALIGN(64) g_work; volatile time_t g_work_time; pthread_mutex_t g_work_lock; // get const array size (defined in ccminer.cpp) int options_count() { int n = 0; while (options[n].name != NULL) n++; return n; } #ifdef __linux /* Linux specific policy and affinity management */ #include static inline void drop_policy(void) { struct sched_param param; param.sched_priority = 0; #ifdef SCHED_IDLE if (unlikely(sched_setscheduler(0, SCHED_IDLE, ¶m) == -1)) #endif #ifdef SCHED_BATCH sched_setscheduler(0, SCHED_BATCH, ¶m); #endif } static void affine_to_cpu_mask(int id, unsigned long mask) { cpu_set_t set; CPU_ZERO(&set); for (uint8_t i = 0; i < num_cpus; i++) { // cpu mask if (mask & (1UL< static inline void drop_policy(void) { } static void affine_to_cpu_mask(int id, unsigned long mask) { cpuset_t set; CPU_ZERO(&set); for (uint8_t i = 0; i < num_cpus; i++) { if (mask & (1UL<data[18] : swab32(work->data[18]); if (opt_algo == ALGO_DECRED) nbits = work->data[29]; uint32_t bits = (nbits & 0xffffff); int16_t shift = (swab32(nbits) & 0xff); // 0x1c = 28 uint64_t diffone = 0x0000FFFF00000000ull; double d = (double)0x0000ffff / (double)bits; for (int m=shift; m < 29; m++) d *= 256.0; for (int m=29; m < shift; m++) d /= 256.0; if (opt_algo == ALGO_DECRED && shift == 28) d *= 256.0; if (opt_debug_diff) applog(LOG_DEBUG, "net diff: %f -> shift %u, bits %08x", d, shift, bits); net_diff = d; } /* decode data from getwork (wallets and longpoll pools) */ static bool work_decode(const json_t *val, struct work *work) { int data_size, target_size = sizeof(work->target); int adata_sz, atarget_sz = ARRAY_SIZE(work->target); int i; switch (opt_algo) { case ALGO_DECRED: data_size = 192; adata_sz = 180/4; break; case ALGO_NEOSCRYPT: case ALGO_ZR5: data_size = 80; adata_sz = data_size / 4; break; default: data_size = 128; adata_sz = data_size / 4; } if (!jobj_binary(val, "data", work->data, data_size)) { json_t *obj = json_object_get(val, "data"); int len = obj ? (int) strlen(json_string_value(obj)) : 0; if (!len || len > sizeof(work->data)*2) { applog(LOG_ERR, "JSON invalid data (len %d <> %d)", len/2, data_size); return false; } else { data_size = len / 2; if (!jobj_binary(val, "data", work->data, data_size)) { applog(LOG_ERR, "JSON invalid data (len %d)", data_size); return false; } } } if (!jobj_binary(val, "target", work->target, target_size)) { applog(LOG_ERR, "JSON invalid target"); return false; } if (opt_algo == ALGO_HEAVY) { if (unlikely(!jobj_binary(val, "maxvote", &work->maxvote, sizeof(work->maxvote)))) { work->maxvote = 2048; } } else work->maxvote = 0; for (i = 0; i < adata_sz; i++) work->data[i] = le32dec(work->data + i); for (i = 0; i < atarget_sz; i++) work->target[i] = le32dec(work->target + i); if ((opt_showdiff || opt_max_diff > 0.) && !allow_mininginfo) calc_network_diff(work); work->targetdiff = target_to_diff(work->target); // for api stats, on longpoll pools stratum_diff = work->targetdiff; work->tx_count = use_pok = 0; if (work->data[0] & POK_BOOL_MASK) { use_pok = 1; json_t *txs = json_object_get(val, "txs"); if (txs && json_is_array(txs)) { size_t idx, totlen = 0; json_t *p; json_array_foreach(txs, idx, p) { const int tx = work->tx_count % POK_MAX_TXS; const char* hexstr = json_string_value(p); size_t txlen = strlen(hexstr)/2; work->tx_count++; if (work->tx_count > POK_MAX_TXS || txlen >= POK_MAX_TX_SZ) { // when tx is too big, just reset use_pok for the block use_pok = 0; if (opt_debug) applog(LOG_WARNING, "pok: large block ignored, tx len: %u", txlen); work->tx_count = 0; break; } hex2bin((uchar*)work->txs[tx].data, hexstr, min(txlen, POK_MAX_TX_SZ)); work->txs[tx].len = (uint32_t) (txlen); totlen += txlen; } if (opt_debug) applog(LOG_DEBUG, "block txs: %u, total len: %u", work->tx_count, totlen); } } /* use work ntime as job id (solo-mining) */ cbin2hex(work->job_id, (const char*)&work->data[17], 4); if (opt_algo == ALGO_DECRED) { uint16_t vote; // always keep last bit of votebits memcpy(&vote, &work->data[25], 2); vote = (opt_vote << 1) | (vote & 1); memcpy(&work->data[25], &vote, 2); // some random extradata to make it unique work->data[36] = (rand()*4); work->data[37] = (rand()*4) << 8; // required for the longpoll pool block info... work->height = work->data[32]; if (!have_longpoll && work->height > net_blocks + 1) { char netinfo[64] = { 0 }; if (opt_showdiff && net_diff > 0.) { if (net_diff != work->targetdiff) sprintf(netinfo, ", diff %.3f, pool %.1f", net_diff, work->targetdiff); else sprintf(netinfo, ", diff %.3f", net_diff); } applog(LOG_BLUE, "%s block %d%s", algo_names[opt_algo], work->height, netinfo); net_blocks = work->height - 1; } cbin2hex(work->job_id, (const char*)&work->data[34], 4); } return true; } #define YES "yes!" #define YAY "yay!!!" #define BOO "booooo" static int share_result(int result, int pooln, double sharediff, const char *reason) { const char *flag; char suppl[32] = { 0 }; char s[32] = { 0 }; double hashrate = 0.; struct pool_infos *p = &pools[pooln]; pthread_mutex_lock(&stats_lock); for (int i = 0; i < opt_n_threads; i++) { hashrate += stats_get_speed(i, thr_hashrates[i]); } pthread_mutex_unlock(&stats_lock); result ? p->accepted_count++ : p->rejected_count++; p->last_share_time = time(NULL); if (sharediff > p->best_share) p->best_share = sharediff; global_hashrate = llround(hashrate); format_hashrate(hashrate, s); if (opt_showdiff) sprintf(suppl, "diff %.3f", sharediff); else // accepted percent sprintf(suppl, "%.2f%%", 100. * p->accepted_count / (p->accepted_count + p->rejected_count)); if (!net_diff || sharediff < net_diff) { flag = use_colors ? (result ? CL_GRN YES : CL_RED BOO) : (result ? "(" YES ")" : "(" BOO ")"); } else { p->solved_count++; flag = use_colors ? (result ? CL_GRN YAY : CL_RED BOO) : (result ? "(" YAY ")" : "(" BOO ")"); } applog(LOG_NOTICE, "accepted: %lu/%lu (%s), %s %s", p->accepted_count, p->accepted_count + p->rejected_count, suppl, s, flag); if (reason) { applog(LOG_WARNING, "reject reason: %s", reason); if (!check_dups && strncasecmp(reason, "duplicate", 9) == 0) { applog(LOG_WARNING, "enabling duplicates check feature"); check_dups = true; g_work_time = 0; } } return 1; } static bool submit_upstream_work(CURL *curl, struct work *work) { char s[512]; struct pool_infos *pool = &pools[work->pooln]; json_t *val, *res, *reason; bool stale_work = false; /* discard if a newer block was received */ stale_work = work->height && work->height < g_work.height; if (have_stratum && !stale_work && opt_algo != ALGO_ZR5 && opt_algo != ALGO_SCRYPT_JANE) { pthread_mutex_lock(&g_work_lock); if (strlen(work->job_id + 8)) stale_work = strncmp(work->job_id + 8, g_work.job_id + 8, sizeof(g_work.job_id) - 8); if (stale_work) { pool->stales_count++; if (opt_debug) applog(LOG_DEBUG, "outdated job %s, new %s stales=%d", work->job_id + 8 , g_work.job_id + 8, pool->stales_count); if (!check_stratum_jobs && pool->stales_count > 5) { if (!opt_quiet) applog(LOG_WARNING, "Enabled stratum stale jobs workaround"); check_stratum_jobs = true; } } pthread_mutex_unlock(&g_work_lock); } if (!have_stratum && !stale_work && allow_gbt) { struct work wheight = { 0 }; if (get_blocktemplate(curl, &wheight)) { if (work->height && work->height < wheight.height) { if (opt_debug) applog(LOG_WARNING, "block %u was already solved", work->height); return true; } } } if (!stale_work && opt_algo == ALGO_ZR5 && !have_stratum) { stale_work = (memcmp(&work->data[1], &g_work.data[1], 68)); } if (!submit_old && stale_work) { if (opt_debug) applog(LOG_WARNING, "stale work detected, discarding"); return true; } if (pool->type & POOL_STRATUM) { uint32_t sent = 0; uint32_t ntime, nonce; char *ntimestr, *noncestr, *xnonce2str, *nvotestr; uint16_t nvote = 0; switch (opt_algo) { case ALGO_BLAKE: case ALGO_BLAKECOIN: case ALGO_BLAKE2S: case ALGO_BMW: case ALGO_VANILLA: // fast algos require that... (todo: regen hash) check_dups = true; le32enc(&ntime, work->data[17]); le32enc(&nonce, work->data[19]); break; case ALGO_DECRED: be16enc(&nvote, *((uint16_t*)&work->data[25])); be32enc(&ntime, work->data[34]); be32enc(&nonce, work->data[35]); break; case ALGO_HEAVY: le32enc(&ntime, work->data[17]); le32enc(&nonce, work->data[19]); be16enc(&nvote, *((uint16_t*)&work->data[20])); break; case ALGO_ZR5: check_dups = true; be32enc(&ntime, work->data[17]); be32enc(&nonce, work->data[19]); break; default: le32enc(&ntime, work->data[17]); le32enc(&nonce, work->data[19]); } noncestr = bin2hex((const uchar*)(&nonce), 4); if (check_dups) sent = hashlog_already_submittted(work->job_id, nonce); if (sent > 0) { sent = (uint32_t) time(NULL) - sent; if (!opt_quiet) { applog(LOG_WARNING, "nonce %s was already sent %u seconds ago", noncestr, sent); hashlog_dump_job(work->job_id); } free(noncestr); // prevent useless computing on some pools g_work_time = 0; restart_threads(); return true; } ntimestr = bin2hex((const uchar*)(&ntime), 4); if (opt_algo == ALGO_DECRED) { xnonce2str = bin2hex((const uchar*)&work->data[36], stratum.xnonce1_size); } else { xnonce2str = bin2hex(work->xnonce2, work->xnonce2_len); } // store to keep/display the solved ratio/diff stratum.sharediff = work->sharediff; if (net_diff && stratum.sharediff > net_diff && (opt_debug || opt_debug_diff)) applog(LOG_INFO, "share diff: %.5f, possible block found!!!", stratum.sharediff); else if (opt_debug_diff) applog(LOG_DEBUG, "share diff: %.5f (x %.1f)", stratum.sharediff, work->shareratio); if (opt_vote) { // ALGO_HEAVY ALGO_DECRED nvotestr = bin2hex((const uchar*)(&nvote), 2); sprintf(s, "{\"method\": \"mining.submit\", \"params\": [" "\"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}", pool->user, work->job_id + 8, xnonce2str, ntimestr, noncestr, nvotestr); free(nvotestr); } else { sprintf(s, "{\"method\": \"mining.submit\", \"params\": [" "\"%s\", \"%s\", \"%s\", \"%s\", \"%s\"], \"id\":4}", pool->user, work->job_id + 8, xnonce2str, ntimestr, noncestr); } free(xnonce2str); free(ntimestr); free(noncestr); gettimeofday(&stratum.tv_submit, NULL); if (unlikely(!stratum_send_line(&stratum, s))) { applog(LOG_ERR, "submit_upstream_work stratum_send_line failed"); return false; } if (check_dups) hashlog_remember_submit(work, nonce); } else { int data_size = 128; int adata_sz = data_size / sizeof(uint32_t); /* build hex string */ char *str = NULL; if (opt_algo == ALGO_ZR5) { data_size = 80; adata_sz = 20; } else if (opt_algo == ALGO_DECRED) { data_size = 192; adata_sz = 180/4; } if (opt_algo != ALGO_HEAVY && opt_algo != ALGO_MJOLLNIR) { for (int i = 0; i < adata_sz; i++) le32enc(work->data + i, work->data[i]); } str = bin2hex((uchar*)work->data, data_size); if (unlikely(!str)) { applog(LOG_ERR, "submit_upstream_work OOM"); return false; } /* build JSON-RPC request */ sprintf(s, "{\"method\": \"getwork\", \"params\": [\"%s\"], \"id\":4}\r\n", str); /* issue JSON-RPC request */ val = json_rpc_call_pool(curl, pool, s, false, false, NULL); if (unlikely(!val)) { applog(LOG_ERR, "submit_upstream_work json_rpc_call failed"); return false; } res = json_object_get(val, "result"); reason = json_object_get(val, "reject-reason"); if (!share_result(json_is_true(res), work->pooln, work->sharediff, reason ? json_string_value(reason) : NULL)) { if (check_dups) hashlog_purge_job(work->job_id); } json_decref(val); free(str); } return true; } /* simplified method to only get some extra infos in solo mode */ static bool gbt_work_decode(const json_t *val, struct work *work) { json_t *err = json_object_get(val, "error"); if (err && !json_is_null(err)) { allow_gbt = false; applog(LOG_INFO, "GBT not supported, block height unavailable"); return false; } if (!work->height) { // complete missing data from getwork json_t *key = json_object_get(val, "height"); if (key && json_is_integer(key)) { work->height = (uint32_t) json_integer_value(key); if (!opt_quiet && work->height > g_work.height) { if (net_diff > 0.) { char netinfo[64] = { 0 }; char srate[32] = { 0 }; sprintf(netinfo, "diff %.2f", net_diff); if (net_hashrate) { format_hashrate((double) net_hashrate, srate); strcat(netinfo, ", net "); strcat(netinfo, srate); } applog(LOG_BLUE, "%s block %d, %s", algo_names[opt_algo], work->height, netinfo); } else { applog(LOG_BLUE, "%s %s block %d", short_url, algo_names[opt_algo], work->height); } g_work.height = work->height; } } } return true; } #define GBT_CAPABILITIES "[\"coinbasetxn\", \"coinbasevalue\", \"longpoll\", \"workid\"]" static const char *gbt_req = "{\"method\": \"getblocktemplate\", \"params\": [{" // "\"capabilities\": " GBT_CAPABILITIES "" "}], \"id\":9}\r\n"; static bool get_blocktemplate(CURL *curl, struct work *work) { struct pool_infos *pool = &pools[work->pooln]; if (!allow_gbt) return false; int curl_err = 0; json_t *val = json_rpc_call_pool(curl, pool, gbt_req, false, false, &curl_err); if (!val && curl_err == -1) { // when getblocktemplate is not supported, disable it allow_gbt = false; if (!opt_quiet) { applog(LOG_BLUE, "gbt not supported, block height notices disabled"); } return false; } bool rc = gbt_work_decode(json_object_get(val, "result"), work); json_decref(val); return rc; } // good alternative for wallet mining, difficulty and net hashrate static const char *info_req = "{\"method\": \"getmininginfo\", \"params\": [], \"id\":8}\r\n"; static bool get_mininginfo(CURL *curl, struct work *work) { struct pool_infos *pool = &pools[work->pooln]; int curl_err = 0; if (have_stratum || have_longpoll || !allow_mininginfo) return false; json_t *val = json_rpc_call_pool(curl, pool, info_req, false, false, &curl_err); if (!val && curl_err == -1) { allow_mininginfo = false; if (opt_debug) { applog(LOG_DEBUG, "getmininginfo not supported"); } return false; } else { json_t *res = json_object_get(val, "result"); // "blocks": 491493 (= current work height - 1) // "difficulty": 0.99607860999999998 // "networkhashps": 56475980 // "netmhashps": 351.74414726 if (res) { json_t *key = json_object_get(res, "difficulty"); if (key) { if (json_is_object(key)) key = json_object_get(key, "proof-of-work"); if (json_is_real(key)) net_diff = json_real_value(key); } key = json_object_get(res, "networkhashps"); if (key && json_is_integer(key)) { net_hashrate = json_integer_value(key); } key = json_object_get(res, "netmhashps"); if (key && json_is_real(key)) { net_hashrate = (uint64_t)(json_real_value(key) * 1e6); } key = json_object_get(res, "blocks"); if (key && json_is_integer(key)) { net_blocks = json_integer_value(key); } } } json_decref(val); return true; } static const char *rpc_req = "{\"method\": \"getwork\", \"params\": [], \"id\":0}\r\n"; static bool get_upstream_work(CURL *curl, struct work *work) { bool rc; struct timeval tv_start, tv_end, diff; struct pool_infos *pool = &pools[work->pooln]; json_t *val; if (opt_debug_threads) applog(LOG_DEBUG, "%s: want_longpoll=%d have_longpoll=%d", __func__, want_longpoll, have_longpoll); gettimeofday(&tv_start, NULL); /* want_longpoll/have_longpoll required here to init/unlock the lp thread */ val = json_rpc_call_pool(curl, pool, rpc_req, want_longpoll, have_longpoll, NULL); gettimeofday(&tv_end, NULL); if (have_stratum || unlikely(work->pooln != cur_pooln)) { if (val) json_decref(val); return false; } if (!val) return false; rc = work_decode(json_object_get(val, "result"), work); if (opt_protocol && rc) { timeval_subtract(&diff, &tv_end, &tv_start); /* show time because curl can be slower against versions/config */ applog(LOG_DEBUG, "got new work in %.2f ms", (1000.0 * diff.tv_sec) + (0.001 * diff.tv_usec)); } json_decref(val); get_mininginfo(curl, work); get_blocktemplate(curl, work); return rc; } static void workio_cmd_free(struct workio_cmd *wc) { if (!wc) return; switch (wc->cmd) { case WC_SUBMIT_WORK: aligned_free(wc->u.work); break; default: /* do nothing */ break; } memset(wc, 0, sizeof(*wc)); /* poison */ free(wc); } static void workio_abort() { struct workio_cmd *wc; /* fill out work request message */ wc = (struct workio_cmd *)calloc(1, sizeof(*wc)); if (!wc) return; wc->cmd = WC_ABORT; /* send work request to workio thread */ if (!tq_push(thr_info[work_thr_id].q, wc)) { workio_cmd_free(wc); } } static bool workio_get_work(struct workio_cmd *wc, CURL *curl) { struct work *ret_work; int failures = 0; ret_work = (struct work*)aligned_calloc(sizeof(struct work)); if (!ret_work) return false; /* assign pool number before rpc calls */ ret_work->pooln = wc->pooln; // applog(LOG_DEBUG, "%s: pool %d", __func__, wc->pooln); /* obtain new work from bitcoin via JSON-RPC */ while (!get_upstream_work(curl, ret_work)) { if (unlikely(ret_work->pooln != cur_pooln)) { applog(LOG_ERR, "get_work json_rpc_call failed"); aligned_free(ret_work); tq_push(wc->thr->q, NULL); return true; } if (unlikely((opt_retries >= 0) && (++failures > opt_retries))) { applog(LOG_ERR, "get_work json_rpc_call failed"); aligned_free(ret_work); return false; } /* pause, then restart work-request loop */ applog(LOG_ERR, "get_work failed, retry after %d seconds", opt_fail_pause); sleep(opt_fail_pause); } /* send work to requesting thread */ if (!tq_push(wc->thr->q, ret_work)) aligned_free(ret_work); return true; } static bool workio_submit_work(struct workio_cmd *wc, CURL *curl) { int failures = 0; uint32_t pooln = wc->pooln; // applog(LOG_DEBUG, "%s: pool %d", __func__, wc->pooln); /* submit solution to bitcoin via JSON-RPC */ while (!submit_upstream_work(curl, wc->u.work)) { if (pooln != cur_pooln) { applog(LOG_DEBUG, "work from pool %u discarded", pooln); return true; } if (unlikely((opt_retries >= 0) && (++failures > opt_retries))) { applog(LOG_ERR, "...terminating workio thread"); return false; } /* pause, then restart work-request loop */ if (!opt_benchmark) applog(LOG_ERR, "...retry after %d seconds", opt_fail_pause); sleep(opt_fail_pause); } return true; } static void *workio_thread(void *userdata) { struct thr_info *mythr = (struct thr_info*)userdata; CURL *curl; bool ok = true; curl = curl_easy_init(); if (unlikely(!curl)) { applog(LOG_ERR, "CURL initialization failed"); return NULL; } while (ok && !abort_flag) { struct workio_cmd *wc; /* wait for workio_cmd sent to us, on our queue */ wc = (struct workio_cmd *)tq_pop(mythr->q, NULL); if (!wc) { ok = false; break; } /* process workio_cmd */ switch (wc->cmd) { case WC_GET_WORK: ok = workio_get_work(wc, curl); break; case WC_SUBMIT_WORK: ok = workio_submit_work(wc, curl); break; case WC_ABORT: default: /* should never happen */ ok = false; break; } if (!ok && num_pools > 1 && opt_pool_failover) { if (opt_debug_threads) applog(LOG_DEBUG, "%s died, failover", __func__); ok = pool_switch_next(-1); tq_push(wc->thr->q, NULL); // get_work() will return false } workio_cmd_free(wc); } if (opt_debug_threads) applog(LOG_DEBUG, "%s() died", __func__); curl_easy_cleanup(curl); tq_freeze(mythr->q); return NULL; } bool get_work(struct thr_info *thr, struct work *work) { struct workio_cmd *wc; struct work *work_heap; if (opt_benchmark) { memset(work->data, 0x55, 76); //work->data[17] = swab32((uint32_t)time(NULL)); memset(work->data + 19, 0x00, 52); if (opt_algo == ALGO_DECRED) { memset(&work->data[35], 0x00, 52); } else { work->data[20] = 0x80000000; work->data[31] = 0x00000280; } memset(work->target, 0x00, sizeof(work->target)); return true; } /* fill out work request message */ wc = (struct workio_cmd *)calloc(1, sizeof(*wc)); if (!wc) return false; wc->cmd = WC_GET_WORK; wc->thr = thr; wc->pooln = cur_pooln; /* send work request to workio thread */ if (!tq_push(thr_info[work_thr_id].q, wc)) { workio_cmd_free(wc); return false; } /* wait for response, a unit of work */ work_heap = (struct work *)tq_pop(thr->q, NULL); if (!work_heap) return false; /* copy returned work into storage provided by caller */ memcpy(work, work_heap, sizeof(*work)); aligned_free(work_heap); return true; } static bool submit_work(struct thr_info *thr, const struct work *work_in) { struct workio_cmd *wc; /* fill out work request message */ wc = (struct workio_cmd *)calloc(1, sizeof(*wc)); if (!wc) return false; wc->u.work = (struct work *)aligned_calloc(sizeof(*work_in)); if (!wc->u.work) goto err_out; wc->cmd = WC_SUBMIT_WORK; wc->thr = thr; memcpy(wc->u.work, work_in, sizeof(struct work)); wc->pooln = work_in->pooln; /* send solution to workio thread */ if (!tq_push(thr_info[work_thr_id].q, wc)) goto err_out; return true; err_out: workio_cmd_free(wc); return false; } static bool stratum_gen_work(struct stratum_ctx *sctx, struct work *work) { uchar merkle_root[64] = { 0 }; int i; if (!sctx->job.job_id) { // applog(LOG_WARNING, "stratum_gen_work: job not yet retrieved"); return false; } pthread_mutex_lock(&stratum_work_lock); // store the job ntime as high part of jobid snprintf(work->job_id, sizeof(work->job_id), "%07x %s", be32dec(sctx->job.ntime) & 0xfffffff, sctx->job.job_id); work->xnonce2_len = sctx->xnonce2_size; memcpy(work->xnonce2, sctx->job.xnonce2, sctx->xnonce2_size); // also store the block number work->height = sctx->job.height; // and the pool of the current stratum work->pooln = sctx->pooln; /* Generate merkle root */ switch (opt_algo) { case ALGO_DECRED: // getwork over stratum, no merkle to generate break; case ALGO_HEAVY: case ALGO_MJOLLNIR: heavycoin_hash(merkle_root, sctx->job.coinbase, (int)sctx->job.coinbase_size); break; case ALGO_FUGUE256: case ALGO_GROESTL: case ALGO_KECCAK: case ALGO_BLAKECOIN: case ALGO_WHIRLCOIN: SHA256((uchar*)sctx->job.coinbase, sctx->job.coinbase_size, (uchar*)merkle_root); break; case ALGO_WHIRLPOOL: default: sha256d(merkle_root, sctx->job.coinbase, (int)sctx->job.coinbase_size); } for (i = 0; i < sctx->job.merkle_count; i++) { memcpy(merkle_root + 32, sctx->job.merkle[i], 32); if (opt_algo == ALGO_HEAVY || opt_algo == ALGO_MJOLLNIR) heavycoin_hash(merkle_root, merkle_root, 64); else sha256d(merkle_root, merkle_root, 64); } /* Increment extranonce2 */ for (i = 0; i < (int)sctx->xnonce2_size && !++sctx->job.xnonce2[i]; i++); /* Assemble block header */ memset(work->data, 0, sizeof(work->data)); work->data[0] = le32dec(sctx->job.version); for (i = 0; i < 8; i++) work->data[1 + i] = le32dec((uint32_t *)sctx->job.prevhash + i); if (opt_algo == ALGO_DECRED) { uint16_t vote; for (i = 0; i < 8; i++) // reversed prevhash work->data[1 + i] = swab32(work->data[1 + i]); // decred header (coinb1) [merkle...nonce] memcpy(&work->data[9], sctx->job.coinbase, 108); // last vote bit should never be changed memcpy(&vote, &work->data[25], 2); vote = (opt_vote << 1) | (vote & 1); memcpy(&work->data[25], &vote, 2); // extradata if (sctx->xnonce1_size > sizeof(work->data)-(36*4)) { // should never happen... applog(LOG_ERR, "extranonce size overflow!"); sctx->xnonce1_size = sizeof(work->data)-(36*4); } memcpy(&work->data[36], sctx->xnonce1, sctx->xnonce1_size); // work->data[36] = swab32(vote); // alt vote submission method work->data[37] = (rand()*4) << 8; // random work data sctx->job.height = work->data[32]; //applog_hex(work->data, 180); } else { for (i = 0; i < 8; i++) work->data[9 + i] = be32dec((uint32_t *)merkle_root + i); work->data[17] = le32dec(sctx->job.ntime); work->data[18] = le32dec(sctx->job.nbits); work->data[20] = 0x80000000; work->data[31] = (opt_algo == ALGO_MJOLLNIR) ? 0x000002A0 : 0x00000280; } if (opt_showdiff || opt_max_diff > 0.) calc_network_diff(work); switch (opt_algo) { case ALGO_MJOLLNIR: case ALGO_HEAVY: case ALGO_ZR5: for (i = 0; i < 20; i++) work->data[i] = swab32(work->data[i]); break; } // HeavyCoin (vote / reward) if (opt_algo == ALGO_HEAVY) { work->maxvote = 2048; uint16_t *ext = (uint16_t*)(&work->data[20]); ext[0] = opt_vote; ext[1] = be16dec(sctx->job.nreward); // applog(LOG_DEBUG, "DEBUG: vote=%hx reward=%hx", ext[0], ext[1]); } pthread_mutex_unlock(&stratum_work_lock); if (opt_debug && opt_algo != ALGO_DECRED) { uint32_t utm = work->data[17]; if (opt_algo != ALGO_ZR5) utm = swab32(utm); char *tm = atime2str(utm - sctx->srvtime_diff); char *xnonce2str = bin2hex(work->xnonce2, sctx->xnonce2_size); applog(LOG_DEBUG, "DEBUG: job_id=%s xnonce2=%s time=%s", work->job_id, xnonce2str, tm); free(tm); free(xnonce2str); } if (opt_difficulty == 0.) opt_difficulty = 1.; switch (opt_algo) { case ALGO_JACKPOT: case ALGO_NEOSCRYPT: case ALGO_SCRYPT: case ALGO_SCRYPT_JANE: work_set_target(work, sctx->job.diff / (65536.0 * opt_difficulty)); break; case ALGO_DMD_GR: case ALGO_FRESH: case ALGO_FUGUE256: case ALGO_GROESTL: case ALGO_LYRA2v2: work_set_target(work, sctx->job.diff / (256.0 * opt_difficulty)); break; case ALGO_KECCAK: case ALGO_LYRA2: work_set_target(work, sctx->job.diff / (128.0 * opt_difficulty)); break; default: work_set_target(work, sctx->job.diff / opt_difficulty); } if (stratum_diff != sctx->job.diff) { char sdiff[32] = { 0 }; // store for api stats stratum_diff = sctx->job.diff; if (opt_showdiff && work->targetdiff != stratum_diff) snprintf(sdiff, 32, " (%.5f)", work->targetdiff); applog(LOG_WARNING, "Stratum difficulty set to %g%s", stratum_diff, sdiff); } return true; } void restart_threads(void) { if (opt_debug && !opt_quiet) applog(LOG_DEBUG,"%s", __FUNCTION__); for (int i = 0; i < opt_n_threads && work_restart; i++) work_restart[i].restart = 1; } static bool wanna_mine(int thr_id) { bool state = true; bool allow_pool_rotate = (thr_id == 0 && num_pools > 1 && !pool_is_switching); if (opt_max_temp > 0.0) { #ifdef USE_WRAPNVML struct cgpu_info * cgpu = &thr_info[thr_id].gpu; float temp = gpu_temp(cgpu); if (temp > opt_max_temp) { if (!conditional_state[thr_id] && !opt_quiet) gpulog(LOG_INFO, thr_id, "temperature too high (%.0f°c), waiting...", temp); state = false; } else if (opt_max_temp > 0. && opt_resume_temp > 0. && conditional_state[thr_id] && temp > opt_resume_temp) { if (!thr_id && opt_debug) applog(LOG_DEBUG, "temperature did not reach resume value %.1f...", opt_resume_temp); state = false; } #endif } // Network Difficulty if (opt_max_diff > 0.0 && net_diff > opt_max_diff) { int next = pool_get_first_valid(cur_pooln+1); if (num_pools > 1 && pools[next].max_diff != pools[cur_pooln].max_diff && opt_resume_diff <= 0.) conditional_pool_rotate = allow_pool_rotate; if (!thr_id && !conditional_state[thr_id] && !opt_quiet) applog(LOG_INFO, "network diff too high, waiting..."); state = false; } else if (opt_max_diff > 0. && opt_resume_diff > 0. && conditional_state[thr_id] && net_diff > opt_resume_diff) { if (!thr_id && opt_debug) applog(LOG_DEBUG, "network diff did not reach resume value %.3f...", opt_resume_diff); state = false; } // Network hashrate if (opt_max_rate > 0.0 && net_hashrate > opt_max_rate) { int next = pool_get_first_valid(cur_pooln+1); if (pools[next].max_rate != pools[cur_pooln].max_rate && opt_resume_rate <= 0.) conditional_pool_rotate = allow_pool_rotate; if (!thr_id && !conditional_state[thr_id] && !opt_quiet) { char rate[32]; format_hashrate(opt_max_rate, rate); applog(LOG_INFO, "network hashrate too high, waiting %s...", rate); } state = false; } else if (opt_max_rate > 0. && opt_resume_rate > 0. && conditional_state[thr_id] && net_hashrate > opt_resume_rate) { if (!thr_id && opt_debug) applog(LOG_DEBUG, "network rate did not reach resume value %.3f...", opt_resume_rate); state = false; } conditional_state[thr_id] = (uint8_t) !state; // only one wait message in logs return state; } static void *miner_thread(void *userdata) { struct thr_info *mythr = (struct thr_info *)userdata; int switchn = pool_switch_count; int thr_id = mythr->id; int dev_id = device_map[thr_id % MAX_GPUS]; struct work work; uint64_t loopcnt = 0; uint32_t max_nonce; uint32_t end_nonce = UINT32_MAX / opt_n_threads * (thr_id + 1) - (thr_id + 1); bool work_done = false; bool extrajob = false; char s[16]; int rc = 0; memset(&work, 0, sizeof(work)); // prevent work from being used uninitialized if (opt_priority > 0) { int prio = 2; // default to normal #ifndef WIN32 prio = 0; // note: different behavior on linux (-19 to 19) switch (opt_priority) { case 0: prio = 15; break; case 1: prio = 5; break; case 2: prio = 0; // normal process break; case 3: prio = -1; // above break; case 4: prio = -10; break; case 5: prio = -15; } if (opt_debug) applog(LOG_DEBUG, "Thread %d priority %d (nice %d)", thr_id, opt_priority, prio); #endif setpriority(PRIO_PROCESS, 0, prio); drop_policy(); } /* Cpu thread affinity */ if (num_cpus > 1) { if (opt_affinity == -1L && opt_n_threads > 1) { if (opt_debug) applog(LOG_DEBUG, "Binding thread %d to cpu %d (mask %x)", thr_id, thr_id % num_cpus, (1UL << (thr_id % num_cpus))); affine_to_cpu_mask(thr_id, 1 << (thr_id % num_cpus)); } else if (opt_affinity != -1L) { if (opt_debug) applog(LOG_DEBUG, "Binding thread %d to cpu mask %lx", thr_id, (long) opt_affinity); affine_to_cpu_mask(thr_id, (unsigned long) opt_affinity); } } while (!abort_flag) { struct timeval tv_start, tv_end, diff; unsigned long hashes_done; uint32_t start_nonce; uint32_t scan_time = have_longpoll ? LP_SCANTIME : opt_scantime; uint64_t max64, minmax = 0x100000; // &work.data[19] int wcmplen = (opt_algo == ALGO_DECRED) ? 140 : 76; int wcmpoft = 0; uint32_t *nonceptr = (uint32_t*) (((char*)work.data) + wcmplen); if (have_stratum) { uint32_t sleeptime = 0; if (opt_algo == ALGO_DECRED) work_done = true; // force "regen" hash while (!work_done && time(NULL) >= (g_work_time + opt_scantime)) { usleep(100*1000); if (sleeptime > 4) { extrajob = true; break; } sleeptime++; } if (sleeptime && opt_debug && !opt_quiet) applog(LOG_DEBUG, "sleeptime: %u ms", sleeptime*100); nonceptr = (uint32_t*) (((char*)work.data) + wcmplen); pthread_mutex_lock(&g_work_lock); extrajob |= work_done; if (nonceptr[0] >= end_nonce || extrajob) { work_done = false; extrajob = false; if (stratum_gen_work(&stratum, &g_work)) g_work_time = time(NULL); } } else { uint32_t secs = 0; pthread_mutex_lock(&g_work_lock); secs = (uint32_t) (time(NULL) - g_work_time); if (secs >= scan_time || nonceptr[0] >= (end_nonce - 0x100)) { if (opt_debug && g_work_time && !opt_quiet) applog(LOG_DEBUG, "work time %u/%us nonce %x/%x", secs, scan_time, nonceptr[0], end_nonce); /* obtain new work from internal workio thread */ if (unlikely(!get_work(mythr, &g_work))) { pthread_mutex_unlock(&g_work_lock); if (switchn != pool_switch_count) { switchn = pool_switch_count; continue; } else { applog(LOG_ERR, "work retrieval failed, exiting mining thread %d", mythr->id); goto out; } } g_work_time = time(NULL); } } if (!opt_benchmark && (g_work.height != work.height || memcmp(work.target, g_work.target, sizeof(work.target)))) { if (opt_debug) { uint64_t target64 = g_work.target[7] * 0x100000000ULL + g_work.target[6]; applog(LOG_DEBUG, "job %s target change: %llx (%.1f)", g_work.job_id, target64, g_work.targetdiff); } memcpy(work.target, g_work.target, sizeof(work.target)); work.targetdiff = g_work.targetdiff; work.height = g_work.height; //nonceptr[0] = (UINT32_MAX / opt_n_threads) * thr_id; // 0 if single thr } if (opt_algo == ALGO_ZR5) { // ignore pok/version header wcmpoft = 1; wcmplen -= 4; } if (memcmp(&work.data[wcmpoft], &g_work.data[wcmpoft], wcmplen)) { #if 0 if (opt_debug) { for (int n=0; n <= (wcmplen-8); n+=8) { if (memcmp(work.data + n, g_work.data + n, 8)) { applog(LOG_DEBUG, "job %s work updated at offset %d:", g_work.job_id, n); applog_hash((uchar*) &work.data[n]); applog_compare_hash((uchar*) &g_work.data[n], (uchar*) &work.data[n]); } } } #endif memcpy(&work, &g_work, sizeof(struct work)); nonceptr[0] = (UINT32_MAX / opt_n_threads) * thr_id; // 0 if single thr } else nonceptr[0]++; //?? if (opt_algo == ALGO_DECRED) { // suprnova job_id check without data/target/height change... if (check_stratum_jobs && strcmp(work.job_id, g_work.job_id)) { pthread_mutex_unlock(&g_work_lock); continue; } // use the full range per loop nonceptr[0] = 0; end_nonce = UINT32_MAX; // and make an unique work (extradata) nonceptr[1] += 1; nonceptr[2] |= thr_id; } else if (opt_benchmark) { // randomize work nonceptr[-1] += 1; } pthread_mutex_unlock(&g_work_lock); // --benchmark [-a all] if (opt_benchmark && bench_algo >= 0) { //gpulog(LOG_DEBUG, thr_id, "loop %d", loopcnt); if (loopcnt >= 3) { if (!bench_algo_switch_next(thr_id) && thr_id == 0) { bench_display_results(); proper_exit(0); break; } loopcnt = 0; } } loopcnt++; /* prevent gpu scans before a job is received */ //if (opt_algo != ALGO_DECRED) // uncomment to allow testnet if (have_stratum && work.data[0] == 0 && !opt_benchmark) { sleep(1); if (!thr_id) pools[cur_pooln].wait_time += 1; continue; } /* conditional mining */ if (!wanna_mine(thr_id)) { // free gpu resources algo_free_all(thr_id); // clear any free error (algo switch) cuda_clear_lasterror(); // conditional pool switch if (num_pools > 1 && conditional_pool_rotate) { if (!pool_is_switching) pool_switch_next(thr_id); else if (time(NULL) - firstwork_time > 35) { if (!opt_quiet) applog(LOG_WARNING, "Pool switching timed out..."); if (!thr_id) pools[cur_pooln].wait_time += 1; pool_is_switching = false; } sleep(1); continue; } pool_on_hold = true; global_hashrate = 0; sleep(5); if (!thr_id) pools[cur_pooln].wait_time += 5; continue; } pool_on_hold = false; work_restart[thr_id].restart = 0; /* adjust max_nonce to meet target scan time */ if (have_stratum) max64 = LP_SCANTIME; else max64 = max(1, (int64_t) scan_time + g_work_time - time(NULL)); /* time limit */ if (opt_time_limit > 0 && firstwork_time) { int passed = (int)(time(NULL) - firstwork_time); int remain = (int)(opt_time_limit - passed); if (remain < 0) { if (thr_id != 0) { sleep(1); continue; } if (num_pools > 1 && pools[cur_pooln].time_limit > 0) { if (!pool_is_switching) { if (!opt_quiet) applog(LOG_INFO, "Pool mining timeout of %ds reached, rotate...", opt_time_limit); pool_switch_next(thr_id); } else if (passed > 35) { // ensure we dont stay locked if pool_is_switching is not reset... applog(LOG_WARNING, "Pool switch to %d timed out...", cur_pooln); if (!thr_id) pools[cur_pooln].wait_time += 1; pool_is_switching = false; } sleep(1); continue; } app_exit_code = EXIT_CODE_TIME_LIMIT; abort_flag = true; if (opt_benchmark) { char rate[32]; format_hashrate((double)global_hashrate, rate); applog(LOG_NOTICE, "Benchmark: %s", rate); usleep(200*1000); fprintf(stderr, "%llu\n", (long long unsigned int) global_hashrate); } else { applog(LOG_NOTICE, "Mining timeout of %ds reached, exiting...", opt_time_limit); } workio_abort(); break; } if (remain < max64) max64 = remain; } max64 *= (uint32_t)thr_hashrates[thr_id]; /* on start, max64 should not be 0, * before hashrate is computed */ if (max64 < minmax) { switch (opt_algo) { case ALGO_BLAKECOIN: case ALGO_BLAKE2S: case ALGO_VANILLA: minmax = 0x80000000U; break; case ALGO_BLAKE: case ALGO_BMW: case ALGO_DECRED: //case ALGO_WHIRLPOOLX: minmax = 0x40000000U; break; case ALGO_KECCAK: case ALGO_LUFFA: case ALGO_SKEIN: case ALGO_SKEIN2: minmax = 0x1000000; break; case ALGO_C11: case ALGO_DEEP: case ALGO_HEAVY: case ALGO_LYRA2v2: case ALGO_S3: case ALGO_X11: case ALGO_X13: case ALGO_WHIRLCOIN: case ALGO_WHIRLPOOL: minmax = 0x400000; break; case ALGO_JACKPOT: case ALGO_X14: case ALGO_X15: minmax = 0x300000; break; case ALGO_LYRA2: case ALGO_NEOSCRYPT: case ALGO_SIB: case ALGO_SCRYPT: minmax = 0x80000; break; case ALGO_SCRYPT_JANE: minmax = 0x1000; break; } max64 = max(minmax-1, max64); } // we can't scan more than uint32 capacity max64 = min(UINT32_MAX, max64); start_nonce = nonceptr[0]; /* never let small ranges at end */ if (end_nonce >= UINT32_MAX - 256) end_nonce = UINT32_MAX; if ((max64 + start_nonce) >= end_nonce) max_nonce = end_nonce; else max_nonce = (uint32_t) (max64 + start_nonce); // todo: keep it rounded to a multiple of 256 ? if (unlikely(start_nonce > max_nonce)) { // should not happen but seen in skein2 benchmark with 2 gpus max_nonce = end_nonce = UINT32_MAX; } work.scanned_from = start_nonce; gpulog(LOG_DEBUG, thr_id, "start=%08x end=%08x range=%08x", start_nonce, max_nonce, (max_nonce-start_nonce)); hashes_done = 0; gettimeofday(&tv_start, NULL); // check (and reset) previous errors cudaError_t err = cudaGetLastError(); if (err != cudaSuccess && !opt_quiet) gpulog(LOG_WARNING, thr_id, "%s", cudaGetErrorString(err)); /* scan nonces for a proof-of-work hash */ switch (opt_algo) { case ALGO_BLAKECOIN: rc = scanhash_blake256(thr_id, &work, max_nonce, &hashes_done, 8); break; case ALGO_BLAKE: rc = scanhash_blake256(thr_id, &work, max_nonce, &hashes_done, 14); break; case ALGO_BLAKE2S: rc = scanhash_blake2s(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_BMW: rc = scanhash_bmw(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_C11: rc = scanhash_c11(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_DECRED: //applog(LOG_BLUE, "version %x, nbits %x, ntime %x extra %x", // work.data[0], work.data[29], work.data[34], work.data[38]); rc = scanhash_decred(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_DEEP: rc = scanhash_deep(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_FRESH: rc = scanhash_fresh(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_FUGUE256: rc = scanhash_fugue256(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_GROESTL: case ALGO_DMD_GR: rc = scanhash_groestlcoin(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_MYR_GR: rc = scanhash_myriad(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_HEAVY: rc = scanhash_heavy(thr_id, &work, max_nonce, &hashes_done, work.maxvote, HEAVYCOIN_BLKHDR_SZ); break; case ALGO_MJOLLNIR: rc = scanhash_heavy(thr_id, &work, max_nonce, &hashes_done, 0, MNR_BLKHDR_SZ); break; case ALGO_KECCAK: rc = scanhash_keccak256(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_JACKPOT: rc = scanhash_jackpot(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_LUFFA: rc = scanhash_luffa(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_QUARK: rc = scanhash_quark(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_QUBIT: rc = scanhash_qubit(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_LYRA2: rc = scanhash_lyra2(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_LYRA2v2: rc = scanhash_lyra2v2(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_NEOSCRYPT: rc = scanhash_neoscrypt(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_NIST5: rc = scanhash_nist5(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_PENTABLAKE: rc = scanhash_pentablake(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_SCRYPT: rc = scanhash_scrypt(thr_id, &work, max_nonce, &hashes_done, NULL, &tv_start, &tv_end); break; case ALGO_SCRYPT_JANE: rc = scanhash_scrypt_jane(thr_id, &work, max_nonce, &hashes_done, NULL, &tv_start, &tv_end); break; case ALGO_SKEIN: rc = scanhash_skeincoin(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_SKEIN2: rc = scanhash_skein2(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_SIB: rc = scanhash_sib(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_S3: rc = scanhash_s3(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_VANILLA: rc = scanhash_vanilla(thr_id, &work, max_nonce, &hashes_done, 8); break; case ALGO_WHIRLCOIN: case ALGO_WHIRLPOOL: rc = scanhash_whirl(thr_id, &work, max_nonce, &hashes_done); break; //case ALGO_WHIRLPOOLX: // rc = scanhash_whirlx(thr_id, &work, max_nonce, &hashes_done); // break; case ALGO_X11: rc = scanhash_x11(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_X13: rc = scanhash_x13(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_X14: rc = scanhash_x14(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_X15: rc = scanhash_x15(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_X17: rc = scanhash_x17(thr_id, &work, max_nonce, &hashes_done); break; case ALGO_ZR5: rc = scanhash_zr5(thr_id, &work, max_nonce, &hashes_done); break; default: /* should never happen */ goto out; } if (abort_flag) break; // time to leave the mining loop... if (work_restart[thr_id].restart) continue; /* record scanhash elapsed time */ gettimeofday(&tv_end, NULL); // todo: update all algos to use work->nonces work.nonces[0] = nonceptr[0]; if (opt_algo != ALGO_DECRED && opt_algo != ALGO_BLAKE2S) { work.nonces[1] = nonceptr[2]; } if (rc > 0 && opt_debug) applog(LOG_NOTICE, CL_CYN "found => %08x" CL_GRN " %08x", work.nonces[0], swab32(work.nonces[0])); if (rc > 1 && opt_debug) applog(LOG_NOTICE, CL_CYN "found => %08x" CL_GRN " %08x", work.nonces[1], swab32(work.nonces[1])); timeval_subtract(&diff, &tv_end, &tv_start); if (diff.tv_usec || diff.tv_sec) { double dtime = (double) diff.tv_sec + 1e-6 * diff.tv_usec; /* hashrate factors for some algos */ double rate_factor = 1.0; switch (opt_algo) { case ALGO_JACKPOT: case ALGO_QUARK: // to stay comparable to other ccminer forks or pools rate_factor = 0.5; break; } /* store thread hashrate */ if (dtime > 0.0) { pthread_mutex_lock(&stats_lock); thr_hashrates[thr_id] = hashes_done / dtime; thr_hashrates[thr_id] *= rate_factor; if (loopcnt > 1) // ignore first (init time) stats_remember_speed(thr_id, hashes_done, thr_hashrates[thr_id], (uint8_t) rc, work.height); pthread_mutex_unlock(&stats_lock); } } if (rc > 0) work.scanned_to = work.nonces[0]; if (rc > 1) work.scanned_to = max(work.nonces[0], work.nonces[1]); else { work.scanned_to = max_nonce; if (opt_debug && opt_benchmark) { // to debug nonce ranges gpulog(LOG_DEBUG, thr_id, "ends=%08x range=%08x", nonceptr[0], (nonceptr[0] - start_nonce)); } // prevent low scan ranges on next loop on fast algos (blake) if (nonceptr[0] > UINT32_MAX - 64) nonceptr[0] = UINT32_MAX; } if (check_dups && opt_algo != ALGO_DECRED) hashlog_remember_scan_range(&work); /* output */ if (!opt_quiet && loopcnt > 1) { format_hashrate(thr_hashrates[thr_id], s); gpulog(LOG_INFO, thr_id, "%s, %s", device_name[dev_id], s); } /* ignore first loop hashrate */ if (firstwork_time && thr_id == (opt_n_threads - 1)) { double hashrate = 0.; pthread_mutex_lock(&stats_lock); for (int i = 0; i < opt_n_threads && thr_hashrates[i]; i++) hashrate += stats_get_speed(i, thr_hashrates[i]); pthread_mutex_unlock(&stats_lock); if (opt_benchmark && bench_algo == -1 && loopcnt > 2) { format_hashrate(hashrate, s); applog(LOG_NOTICE, "Total: %s", s); } // since pool start pools[cur_pooln].work_time = (uint32_t) (time(NULL) - firstwork_time); // X-Mining-Hashrate global_hashrate = llround(hashrate); } if (firstwork_time == 0) firstwork_time = time(NULL); /* if nonce found, submit work */ if (rc > 0 && !opt_benchmark) { if (!submit_work(mythr, &work)) break; // prevent stale work in solo // we can't submit twice a block! if (!have_stratum && !have_longpoll) { pthread_mutex_lock(&g_work_lock); // will force getwork g_work_time = 0; pthread_mutex_unlock(&g_work_lock); continue; } // second nonce found, submit too (on pool only!) if (rc > 1 && work.nonces[1]) { nonceptr[0] = work.nonces[1]; if (opt_algo == ALGO_ZR5) { // todo: use + 4..6 index for pok to allow multiple nonces work.data[0] = work.data[22]; // pok work.data[22] = 0; } if (!submit_work(mythr, &work)) break; } } } out: if (opt_debug_threads) applog(LOG_DEBUG, "%s() died", __func__); tq_freeze(mythr->q); return NULL; } static void *longpoll_thread(void *userdata) { struct thr_info *mythr = (struct thr_info *)userdata; struct pool_infos *pool; CURL *curl = NULL; char *hdr_path = NULL, *lp_url = NULL; bool need_slash = false; int pooln, switchn; curl = curl_easy_init(); if (unlikely(!curl)) { applog(LOG_ERR, "%s() CURL init failed", __func__); goto out; } wait_lp_url: hdr_path = (char*)tq_pop(mythr->q, NULL); // wait /LP url if (!hdr_path) goto out; if (!(pools[cur_pooln].type & POOL_STRATUM)) { pooln = cur_pooln; pool = &pools[pooln]; } else { // hack... have_stratum = true; } // to detect pool switch during loop switchn = pool_switch_count; /* full URL */ if (strstr(hdr_path, "://")) { lp_url = hdr_path; hdr_path = NULL; } /* absolute path, on current server */ else { char *copy_start = (*hdr_path == '/') ? (hdr_path + 1) : hdr_path; if (rpc_url[strlen(rpc_url) - 1] != '/') need_slash = true; lp_url = (char*)malloc(strlen(rpc_url) + strlen(copy_start) + 2); if (!lp_url) goto out; sprintf(lp_url, "%s%s%s", rpc_url, need_slash ? "/" : "", copy_start); } if (!pool_is_switching) applog(LOG_BLUE, "Long-polling on %s", lp_url); pool_is_switching = false; pool->type |= POOL_LONGPOLL; longpoll_retry: while (!abort_flag) { json_t *val = NULL, *soval; int err = 0; if (opt_debug_threads) applog(LOG_DEBUG, "longpoll %d: %d count %d %d, switching=%d, have_stratum=%d", pooln, cur_pooln, switchn, pool_switch_count, pool_is_switching, have_stratum); // exit on pool switch if (switchn != pool_switch_count) goto need_reinit; val = json_rpc_longpoll(curl, lp_url, pool, rpc_req, &err); if (have_stratum || switchn != pool_switch_count) { if (val) json_decref(val); goto need_reinit; } if (likely(val)) { soval = json_object_get(json_object_get(val, "result"), "submitold"); submit_old = soval ? json_is_true(soval) : false; pthread_mutex_lock(&g_work_lock); if (work_decode(json_object_get(val, "result"), &g_work)) { restart_threads(); if (!opt_quiet) { char netinfo[64] = { 0 }; if (net_diff > 0.) { sprintf(netinfo, ", diff %.3f", net_diff); } if (opt_showdiff) { sprintf(&netinfo[strlen(netinfo)], ", target %.3f", g_work.targetdiff); } if (g_work.height) applog(LOG_BLUE, "%s block %u%s", algo_names[opt_algo], g_work.height, netinfo); else applog(LOG_BLUE, "%s detected new block%s", short_url, netinfo); } g_work_time = time(NULL); } pthread_mutex_unlock(&g_work_lock); json_decref(val); } else { // to check... g_work_time = 0; if (err != CURLE_OPERATION_TIMEDOUT) { if (opt_debug_threads) applog(LOG_DEBUG, "%s() err %d, retry in %s seconds", __func__, err, opt_fail_pause); sleep(opt_fail_pause); goto longpoll_retry; } } } out: have_longpoll = false; if (opt_debug_threads) applog(LOG_DEBUG, "%s() died", __func__); free(hdr_path); free(lp_url); tq_freeze(mythr->q); if (curl) curl_easy_cleanup(curl); return NULL; need_reinit: /* this thread should not die to allow pool switch */ have_longpoll = false; if (opt_debug_threads) applog(LOG_DEBUG, "%s() reinit...", __func__); if (hdr_path) free(hdr_path); hdr_path = NULL; if (lp_url) free(lp_url); lp_url = NULL; goto wait_lp_url; } static bool stratum_handle_response(char *buf) { json_t *val, *err_val, *res_val, *id_val; json_error_t err; struct timeval tv_answer, diff; bool ret = false; val = JSON_LOADS(buf, &err); if (!val) { applog(LOG_INFO, "JSON decode failed(%d): %s", err.line, err.text); goto out; } res_val = json_object_get(val, "result"); err_val = json_object_get(val, "error"); id_val = json_object_get(val, "id"); if (!id_val || json_is_null(id_val) || !res_val) goto out; // ignore subscribe late answer (yaamp) if (json_integer_value(id_val) < 4) goto out; gettimeofday(&tv_answer, NULL); timeval_subtract(&diff, &tv_answer, &stratum.tv_submit); // store time required to the pool to answer to a submit stratum.answer_msec = (1000 * diff.tv_sec) + (uint32_t) (0.001 * diff.tv_usec); share_result(json_is_true(res_val), stratum.pooln, stratum.sharediff, err_val ? json_string_value(json_array_get(err_val, 1)) : NULL); ret = true; out: if (val) json_decref(val); return ret; } static void *stratum_thread(void *userdata) { struct thr_info *mythr = (struct thr_info *)userdata; struct pool_infos *pool; stratum_ctx *ctx = &stratum; int pooln, switchn; char *s; wait_stratum_url: stratum.url = (char*)tq_pop(mythr->q, NULL); if (!stratum.url) goto out; if (!pool_is_switching) applog(LOG_BLUE, "Starting on %s", stratum.url); ctx->pooln = pooln = cur_pooln; switchn = pool_switch_count; pool = &pools[pooln]; pool_is_switching = false; stratum_need_reset = false; while (!abort_flag) { int failures = 0; if (stratum_need_reset) { stratum_need_reset = false; if (stratum.url) stratum_disconnect(&stratum); else stratum.url = strdup(pool->url); // may be useless } while (!stratum.curl && !abort_flag) { pthread_mutex_lock(&g_work_lock); g_work_time = 0; g_work.data[0] = 0; pthread_mutex_unlock(&g_work_lock); restart_threads(); if (!stratum_connect(&stratum, pool->url) || !stratum_subscribe(&stratum) || !stratum_authorize(&stratum, pool->user, pool->pass)) { stratum_disconnect(&stratum); if (opt_retries >= 0 && ++failures > opt_retries) { if (num_pools > 1 && opt_pool_failover) { applog(LOG_WARNING, "Stratum connect timeout, failover..."); pool_switch_next(-1); } else { applog(LOG_ERR, "...terminating workio thread"); //tq_push(thr_info[work_thr_id].q, NULL); workio_abort(); proper_exit(EXIT_CODE_POOL_TIMEOUT); goto out; } } if (switchn != pool_switch_count) goto pool_switched; if (!opt_benchmark) applog(LOG_ERR, "...retry after %d seconds", opt_fail_pause); sleep(opt_fail_pause); } } if (switchn != pool_switch_count) goto pool_switched; if (stratum.job.job_id && (!g_work_time || strncmp(stratum.job.job_id, g_work.job_id + 8, sizeof(g_work.job_id)-8))) { pthread_mutex_lock(&g_work_lock); if (stratum_gen_work(&stratum, &g_work)) g_work_time = time(NULL); if (stratum.job.clean) { static uint32_t last_bloc_height; if (!opt_quiet && stratum.job.height != last_bloc_height) { last_bloc_height = stratum.job.height; if (net_diff > 0.) applog(LOG_BLUE, "%s block %d, diff %.3f", algo_names[opt_algo], stratum.job.height, net_diff); else applog(LOG_BLUE, "%s %s block %d", pool->short_url, algo_names[opt_algo], stratum.job.height); } restart_threads(); if (check_dups) hashlog_purge_old(); stats_purge_old(); } else if (opt_debug && !opt_quiet) { applog(LOG_BLUE, "%s asks job %d for block %d", pool->short_url, strtoul(stratum.job.job_id, NULL, 16), stratum.job.height); } pthread_mutex_unlock(&g_work_lock); } // check we are on the right pool if (switchn != pool_switch_count) goto pool_switched; if (!stratum_socket_full(&stratum, opt_timeout)) { if (opt_debug) applog(LOG_WARNING, "Stratum connection timed out"); s = NULL; } else s = stratum_recv_line(&stratum); // double check we are on the right pool if (switchn != pool_switch_count) goto pool_switched; if (!s) { stratum_disconnect(&stratum); if (!opt_quiet && !pool_on_hold) applog(LOG_WARNING, "Stratum connection interrupted"); continue; } if (!stratum_handle_method(&stratum, s)) stratum_handle_response(s); free(s); } out: if (opt_debug_threads) applog(LOG_DEBUG, "%s() died", __func__); return NULL; pool_switched: /* this thread should not die on pool switch */ stratum_disconnect(&(pools[pooln].stratum)); if (stratum.url) free(stratum.url); stratum.url = NULL; if (opt_debug_threads) applog(LOG_DEBUG, "%s() reinit...", __func__); goto wait_stratum_url; } static void show_version_and_exit(void) { printf("%s v%s\n" #ifdef WIN32 "pthreads static %s\n" #endif "%s\n", PACKAGE_NAME, PACKAGE_VERSION, #ifdef WIN32 PTW32_VERSION_STRING, #endif curl_version()); proper_exit(EXIT_CODE_OK); } static void show_usage_and_exit(int status) { if (status) fprintf(stderr, "Try `" PROGRAM_NAME " --help' for more information.\n"); else printf(usage); if (opt_algo == ALGO_SCRYPT || opt_algo == ALGO_SCRYPT_JANE) { printf(scrypt_usage); } proper_exit(status); } void parse_arg(int key, char *arg) { char *p = arg; int v, i; uint64_t ul; double d; switch(key) { case 'a': /* --algo */ p = strstr(arg, ":"); // optional factor if (p) *p = '\0'; i = algo_to_int(arg); if (i >= 0) opt_algo = (enum sha_algos)i; else { applog(LOG_ERR, "Unknown algo parameter '%s'", arg); show_usage_and_exit(1); } if (p) { opt_nfactor = atoi(p + 1); if (opt_algo == ALGO_SCRYPT_JANE) { free(jane_params); jane_params = strdup(p+1); } } if (!opt_nfactor) { switch (opt_algo) { case ALGO_SCRYPT: opt_nfactor = 9; break; case ALGO_SCRYPT_JANE: opt_nfactor = 14; break; } } break; case 'b': p = strstr(arg, ":"); if (p) { /* ip:port */ if (p - arg > 0) { free(opt_api_allow); opt_api_allow = strdup(arg); opt_api_allow[p - arg] = '\0'; } opt_api_listen = atoi(p + 1); } else if (arg && strstr(arg, ".")) { /* ip only */ free(opt_api_allow); opt_api_allow = strdup(arg); } else if (arg) { /* port or 0 to disable */ opt_api_listen = atoi(arg); } break; case 1030: /* --api-remote */ opt_api_remote = 1; break; case 'B': opt_background = true; break; case 'c': { json_error_t err; if (opt_config) { json_decref(opt_config); opt_config = NULL; } if (arg && strstr(arg, "://")) { opt_config = json_load_url(arg, &err); } else { opt_config = JSON_LOADF(arg, &err); } if (!json_is_object(opt_config)) { applog(LOG_ERR, "JSON decode of %s failed", arg); proper_exit(EXIT_CODE_USAGE); } break; } case 'i': d = atof(arg); v = (uint32_t) d; if (v < 0 || v > 31) show_usage_and_exit(1); { int n = 0; int ngpus = cuda_num_devices(); uint32_t last = 0; char * pch = strtok(arg,","); while (pch != NULL) { d = atof(pch); v = (uint32_t) d; if (v > 7) { /* 0 = default */ if ((d - v) > 0.0) { uint32_t adds = (uint32_t)floor((d - v) * (1 << (v - 8))) * 256; gpus_intensity[n] = (1 << v) + adds; applog(LOG_INFO, "Adding %u threads to intensity %u, %u cuda threads", adds, v, gpus_intensity[n]); } else if (gpus_intensity[n] != (1 << v)) { gpus_intensity[n] = (1 << v); applog(LOG_INFO, "Intensity set to %u, %u cuda threads", v, gpus_intensity[n]); } } last = gpus_intensity[n]; n++; pch = strtok(NULL, ","); } while (n < MAX_GPUS) gpus_intensity[n++] = last; } break; case 'D': opt_debug = true; break; case 'N': v = atoi(arg); if (v < 1) opt_statsavg = INT_MAX; opt_statsavg = v; break; case 'n': /* --ndevs */ // to get gpu vendors... #ifdef USE_WRAPNVML hnvml = nvml_create(); #ifdef WIN32 if (!hnvml) nvapi_init(); #endif #endif cuda_print_devices(); proper_exit(EXIT_CODE_OK); break; case 'q': opt_quiet = true; break; case 'p': free(rpc_pass); rpc_pass = strdup(arg); pool_set_creds(cur_pooln); break; case 'P': opt_protocol = true; break; case 'r': v = atoi(arg); if (v < -1 || v > 9999) /* sanity check */ show_usage_and_exit(1); opt_retries = v; break; case 'R': v = atoi(arg); if (v < 1 || v > 9999) /* sanity check */ show_usage_and_exit(1); opt_fail_pause = v; break; case 's': v = atoi(arg); if (v < 1 || v > 9999) /* sanity check */ show_usage_and_exit(1); opt_scantime = v; break; case 'T': v = atoi(arg); if (v < 1 || v > 99999) /* sanity check */ show_usage_and_exit(1); opt_timeout = v; break; case 't': v = atoi(arg); if (v < 0 || v > 9999) /* sanity check */ show_usage_and_exit(1); opt_n_threads = v; break; case 1022: // --vote v = atoi(arg); if (v < 0 || v > 8192) /* sanity check */ show_usage_and_exit(1); opt_vote = (uint16_t)v; break; case 1023: // --trust-pool opt_trust_pool = true; break; case 'u': free(rpc_user); rpc_user = strdup(arg); pool_set_creds(cur_pooln); break; case 'o': /* --url */ if (pools[cur_pooln].type != POOL_UNUSED) { // rotate pool pointer cur_pooln = (cur_pooln + 1) % MAX_POOLS; num_pools = max(cur_pooln+1, num_pools); // change some defaults if multi pools if (opt_retries == -1) opt_retries = 1; if (opt_fail_pause == 30) opt_fail_pause = 5; if (opt_timeout == 300) opt_timeout = 60; } p = strstr(arg, "://"); if (p) { if (strncasecmp(arg, "http://", 7) && strncasecmp(arg, "https://", 8) && strncasecmp(arg, "stratum+tcp://", 14)) show_usage_and_exit(1); free(rpc_url); rpc_url = strdup(arg); short_url = &rpc_url[(p - arg) + 3]; } else { if (!strlen(arg) || *arg == '/') show_usage_and_exit(1); free(rpc_url); rpc_url = (char*)malloc(strlen(arg) + 8); sprintf(rpc_url, "http://%s", arg); short_url = &rpc_url[7]; } p = strrchr(rpc_url, '@'); if (p) { char *sp, *ap; *p = '\0'; ap = strstr(rpc_url, "://") + 3; sp = strchr(ap, ':'); if (sp && sp < p) { free(rpc_user); rpc_user = (char*)calloc(sp - ap + 1, 1); strncpy(rpc_user, ap, sp - ap); free(rpc_pass); rpc_pass = strdup(sp + 1); } else { free(rpc_user); rpc_user = strdup(ap); } // remove user[:pass]@ from rpc_url memmove(ap, p + 1, strlen(p + 1) + 1); // host:port only short_url = ap; } have_stratum = !opt_benchmark && !strncasecmp(rpc_url, "stratum", 7); pool_set_creds(cur_pooln); break; case 'O': /* --userpass */ p = strchr(arg, ':'); if (!p) show_usage_and_exit(1); free(rpc_user); rpc_user = (char*)calloc(p - arg + 1, 1); strncpy(rpc_user, arg, p - arg); free(rpc_pass); rpc_pass = strdup(p + 1); pool_set_creds(cur_pooln); break; case 'x': /* --proxy */ if (!strncasecmp(arg, "socks4://", 9)) opt_proxy_type = CURLPROXY_SOCKS4; else if (!strncasecmp(arg, "socks5://", 9)) opt_proxy_type = CURLPROXY_SOCKS5; #if LIBCURL_VERSION_NUM >= 0x071200 else if (!strncasecmp(arg, "socks4a://", 10)) opt_proxy_type = CURLPROXY_SOCKS4A; else if (!strncasecmp(arg, "socks5h://", 10)) opt_proxy_type = CURLPROXY_SOCKS5_HOSTNAME; #endif else opt_proxy_type = CURLPROXY_HTTP; free(opt_proxy); opt_proxy = strdup(arg); pool_set_creds(cur_pooln); break; case 1001: free(opt_cert); opt_cert = strdup(arg); break; case 1002: use_colors = false; break; case 1004: opt_autotune = false; break; case 'l': /* scrypt --launch-config */ { char *last = NULL, *pch = strtok(arg,","); int n = 0; while (pch != NULL) { device_config[n++] = last = strdup(pch); pch = strtok(NULL, ","); } while (n < MAX_GPUS) device_config[n++] = last; } break; case 'L': /* scrypt --lookup-gap */ { char *pch = strtok(arg,","); int n = 0, last = atoi(arg); while (pch != NULL) { device_lookup_gap[n++] = last = atoi(pch); pch = strtok(NULL, ","); } while (n < MAX_GPUS) device_lookup_gap[n++] = last; } break; case 1050: /* scrypt --interactive */ { char *pch = strtok(arg,","); int n = 0, last = atoi(arg); while (pch != NULL) { device_interactive[n++] = last = atoi(pch); pch = strtok(NULL, ","); } while (n < MAX_GPUS) device_interactive[n++] = last; } break; case 1051: /* scrypt --texture-cache */ { char *pch = strtok(arg,","); int n = 0, last = atoi(arg); while (pch != NULL) { device_texturecache[n++] = last = atoi(pch); pch = strtok(NULL, ","); } while (n < MAX_GPUS) device_texturecache[n++] = last; } break; case 1070: /* --gpu-clock */ { char *pch = strtok(arg,","); int n = 0; while (pch != NULL && n < MAX_GPUS) { int dev_id = device_map[n++]; device_gpu_clocks[dev_id] = atoi(pch); pch = strtok(NULL, ","); } } break; case 1071: /* --mem-clock */ { char *pch = strtok(arg,","); int n = 0; while (pch != NULL && n < MAX_GPUS) { int dev_id = device_map[n++]; device_mem_clocks[dev_id] = atoi(pch); pch = strtok(NULL, ","); } } break; case 1072: /* --pstate */ { char *pch = strtok(arg,","); int n = 0; while (pch != NULL && n < MAX_GPUS) { int dev_id = device_map[n++]; device_pstate[dev_id] = (int8_t) atoi(pch); pch = strtok(NULL, ","); } } break; case 1073: /* --plimit */ { char *pch = strtok(arg,","); int n = 0; while (pch != NULL && n < MAX_GPUS) { int dev_id = device_map[n++]; device_plimit[dev_id] = atoi(pch); pch = strtok(NULL, ","); } } break; case 1074: /* --keep-clocks */ opt_keep_clocks = true; break; case 1005: opt_benchmark = true; want_longpoll = false; want_stratum = false; have_stratum = false; break; case 1006: print_hash_tests(); proper_exit(EXIT_CODE_OK); break; case 1003: want_longpoll = false; break; case 1007: want_stratum = false; opt_extranonce = false; break; case 1008: opt_time_limit = atoi(arg); break; case 1011: allow_gbt = false; break; case 1012: opt_extranonce = false; break; case 1013: opt_showdiff = true; break; case 'S': case 1018: applog(LOG_INFO, "Now logging to syslog..."); use_syslog = true; if (arg && strlen(arg)) { free(opt_syslog_pfx); opt_syslog_pfx = strdup(arg); } break; case 1020: p = strstr(arg, "0x"); ul = p ? strtoul(p, NULL, 16) : atol(arg); if (ul > (1UL< 5) /* sanity check */ show_usage_and_exit(1); opt_priority = v; break; case 1025: // cuda-schedule opt_cudaschedule = atoi(arg); break; case 1060: // max-temp d = atof(arg); opt_max_temp = d; break; case 1061: // max-diff d = atof(arg); opt_max_diff = d; break; case 1062: // max-rate d = atof(arg); p = strstr(arg, "K"); if (p) d *= 1e3; p = strstr(arg, "M"); if (p) d *= 1e6; p = strstr(arg, "G"); if (p) d *= 1e9; opt_max_rate = d; break; case 1063: // resume-diff d = atof(arg); opt_resume_diff = d; break; case 1064: // resume-rate d = atof(arg); p = strstr(arg, "K"); if (p) d *= 1e3; p = strstr(arg, "M"); if (p) d *= 1e6; p = strstr(arg, "G"); if (p) d *= 1e9; opt_resume_rate = d; break; case 1065: // resume-temp d = atof(arg); opt_resume_temp = d; break; case 'd': // --device { int device_thr[MAX_GPUS] = { 0 }; int ngpus = cuda_num_devices(); char * pch = strtok (arg,","); opt_n_threads = 0; while (pch != NULL && opt_n_threads < MAX_GPUS) { if (pch[0] >= '0' && pch[0] <= '9' && pch[1] == '\0') { if (atoi(pch) < ngpus) device_map[opt_n_threads++] = atoi(pch); else { applog(LOG_ERR, "Non-existant CUDA device #%d specified in -d option", atoi(pch)); proper_exit(EXIT_CODE_CUDA_NODEVICE); } } else { int device = cuda_finddevice(pch); if (device >= 0 && device < ngpus) device_map[opt_n_threads++] = device; else { applog(LOG_ERR, "Non-existant CUDA device '%s' specified in -d option", pch); proper_exit(EXIT_CODE_CUDA_NODEVICE); } } pch = strtok (NULL, ","); } // count threads per gpu for (int n=0; n < opt_n_threads; n++) { int device = device_map[n]; device_thr[device]++; } for (int n=0; n < ngpus; n++) { gpu_threads = max(gpu_threads, device_thr[n]); } } break; case 'f': // --diff-factor d = atof(arg); if (d <= 0.) show_usage_and_exit(1); opt_difficulty = d; break; case 'm': // --diff-multiplier d = atof(arg); if (d <= 0.) show_usage_and_exit(1); opt_difficulty = 1.0/d; break; /* PER POOL CONFIG OPTIONS */ case 1100: /* pool name */ pool_set_attr(cur_pooln, "name", arg); break; case 1101: /* pool algo */ pool_set_attr(cur_pooln, "algo", arg); break; case 1102: /* pool scantime */ pool_set_attr(cur_pooln, "scantime", arg); break; case 1108: /* pool time-limit */ pool_set_attr(cur_pooln, "time-limit", arg); break; case 1161: /* pool max-diff */ pool_set_attr(cur_pooln, "max-diff", arg); break; case 1162: /* pool max-rate */ pool_set_attr(cur_pooln, "max-rate", arg); break; case 1199: pool_set_attr(cur_pooln, "disabled", arg); break; case 'V': show_version_and_exit(); case 'h': show_usage_and_exit(0); default: show_usage_and_exit(1); } if (use_syslog) use_colors = false; } void parse_config(json_t* json_obj) { int i; json_t *val; if (!json_is_object(json_obj)) return; for (i = 0; i < ARRAY_SIZE(options); i++) { if (!options[i].name) break; if (!strcasecmp(options[i].name, "config")) continue; val = json_object_get(json_obj, options[i].name); if (!val) continue; if (options[i].has_arg && json_is_string(val)) { char *s = strdup(json_string_value(val)); if (!s) continue; parse_arg(options[i].val, s); free(s); } else if (options[i].has_arg && json_is_integer(val)) { char buf[16]; sprintf(buf, "%d", (int) json_integer_value(val)); parse_arg(options[i].val, buf); } else if (options[i].has_arg && json_is_real(val)) { char buf[16]; sprintf(buf, "%f", json_real_value(val)); parse_arg(options[i].val, buf); } else if (!options[i].has_arg) { if (json_is_true(val)) parse_arg(options[i].val, (char*) ""); } else applog(LOG_ERR, "JSON option %s invalid", options[i].name); } val = json_object_get(json_obj, "pools"); if (val && json_typeof(val) == JSON_ARRAY) { parse_pool_array(val); } } static void parse_cmdline(int argc, char *argv[]) { int key; while (1) { #if HAVE_GETOPT_LONG key = getopt_long(argc, argv, short_options, options, NULL); #else key = getopt(argc, argv, short_options); #endif if (key < 0) break; parse_arg(key, optarg); } if (optind < argc) { fprintf(stderr, "%s: unsupported non-option argument '%s' (see --help)\n", argv[0], argv[optind]); //show_usage_and_exit(1); } parse_config(opt_config); if (opt_algo == ALGO_HEAVY && opt_vote == 9999 && !opt_benchmark) { fprintf(stderr, "%s: Heavycoin hash requires block reward vote parameter (see --vote)\n", argv[0]); show_usage_and_exit(1); } if (opt_algo == ALGO_DECRED && opt_vote == 9999) { opt_vote = 0; // default, don't vote } } #ifndef WIN32 static void signal_handler(int sig) { switch (sig) { case SIGHUP: applog(LOG_INFO, "SIGHUP received"); break; case SIGINT: signal(sig, SIG_IGN); applog(LOG_INFO, "SIGINT received, exiting"); proper_exit(EXIT_CODE_KILLED); break; case SIGTERM: applog(LOG_INFO, "SIGTERM received, exiting"); proper_exit(EXIT_CODE_KILLED); break; } } #else BOOL WINAPI ConsoleHandler(DWORD dwType) { switch (dwType) { case CTRL_C_EVENT: applog(LOG_INFO, "CTRL_C_EVENT received, exiting"); proper_exit(EXIT_CODE_KILLED); break; case CTRL_BREAK_EVENT: applog(LOG_INFO, "CTRL_BREAK_EVENT received, exiting"); proper_exit(EXIT_CODE_KILLED); break; case CTRL_LOGOFF_EVENT: applog(LOG_INFO, "CTRL_LOGOFF_EVENT received, exiting"); proper_exit(EXIT_CODE_KILLED); break; case CTRL_SHUTDOWN_EVENT: applog(LOG_INFO, "CTRL_SHUTDOWN_EVENT received, exiting"); proper_exit(EXIT_CODE_KILLED); break; default: return false; } return true; } #endif int main(int argc, char *argv[]) { struct thr_info *thr; long flags; int i; printf("*** ccminer " PACKAGE_VERSION " for nVidia GPUs by tpruvot@github ***\n"); #ifdef _MSC_VER printf(" Built with VC++ 2013 and nVidia CUDA SDK %d.%d\n\n", #else printf(" Built with the nVidia CUDA Toolkit %d.%d\n\n", #endif CUDART_VERSION/1000, (CUDART_VERSION % 1000)/10); printf(" Originally based on Christian Buchner and Christian H. project\n"); printf(" Include some of the work of djm34, sp, tsiv and klausT.\n\n"); printf("BTC donation address: 1AJdfCpLWPNoAMDfHF1wD5y8VgKSSTHxPo (tpruvot)\n\n"); rpc_user = strdup(""); rpc_pass = strdup(""); rpc_url = strdup(""); jane_params = strdup(""); pthread_mutex_init(&applog_lock, NULL); pthread_mutex_init(&stratum_sock_lock, NULL); pthread_mutex_init(&stratum_work_lock, NULL); pthread_mutex_init(&stats_lock, NULL); pthread_mutex_init(&g_work_lock, NULL); // number of cpus for thread affinity #if defined(WIN32) SYSTEM_INFO sysinfo; GetSystemInfo(&sysinfo); num_cpus = sysinfo.dwNumberOfProcessors; #elif defined(_SC_NPROCESSORS_CONF) num_cpus = sysconf(_SC_NPROCESSORS_CONF); #elif defined(CTL_HW) && defined(HW_NCPU) int req[] = { CTL_HW, HW_NCPU }; size_t len = sizeof(num_cpus); sysctl(req, 2, &num_cpus, &len, NULL, 0); #else num_cpus = 1; #endif if (num_cpus < 1) num_cpus = 1; // number of gpus active_gpus = cuda_num_devices(); for (i = 0; i < MAX_GPUS; i++) { device_map[i] = i % active_gpus; device_name[i] = NULL; device_config[i] = NULL; device_backoff[i] = is_windows() ? 12 : 2; device_lookup_gap[i] = 1; device_batchsize[i] = 1024; device_interactive[i] = -1; device_texturecache[i] = -1; device_singlememory[i] = -1; device_pstate[i] = -1; } cuda_devicenames(); /* parse command line */ parse_cmdline(argc, argv); // extra credits.. if (opt_algo == ALGO_VANILLA) { printf(" Vanilla blake optimized by Alexis Provos.\n"); printf("VNL donation address: Vr5oCen8NrY6ekBWFaaWjCUFBH4dyiS57W\n\n"); } if (!opt_benchmark && !strlen(rpc_url)) { // try default config file (user then binary folder) char defconfig[MAX_PATH] = { 0 }; get_defconfig_path(defconfig, MAX_PATH, argv[0]); if (strlen(defconfig)) { if (opt_debug) applog(LOG_DEBUG, "Using config %s", defconfig); parse_arg('c', defconfig); parse_cmdline(argc, argv); } } if (!strlen(rpc_url)) { if (!opt_benchmark) { fprintf(stderr, "%s: no URL supplied\n", argv[0]); show_usage_and_exit(1); } // ensure a pool is set with default params... pool_set_creds(0); } /* init stratum data.. */ memset(&stratum.url, 0, sizeof(stratum)); // ensure default params are set pool_init_defaults(); if (opt_debug) pool_dump_infos(); cur_pooln = pool_get_first_valid(0); pool_switch(-1, cur_pooln); if (opt_algo == ALGO_DECRED) { allow_gbt = false; allow_mininginfo = false; } flags = !opt_benchmark && strncmp(rpc_url, "https:", 6) ? (CURL_GLOBAL_ALL & ~CURL_GLOBAL_SSL) : CURL_GLOBAL_ALL; if (curl_global_init(flags)) { applog(LOG_ERR, "CURL initialization failed"); return EXIT_CODE_SW_INIT_ERROR; } if (opt_background) { #ifndef WIN32 i = fork(); if (i < 0) proper_exit(EXIT_CODE_SW_INIT_ERROR); if (i > 0) proper_exit(EXIT_CODE_OK); i = setsid(); if (i < 0) applog(LOG_ERR, "setsid() failed (errno = %d)", errno); i = chdir("/"); if (i < 0) applog(LOG_ERR, "chdir() failed (errno = %d)", errno); signal(SIGHUP, signal_handler); signal(SIGTERM, signal_handler); #else HWND hcon = GetConsoleWindow(); if (hcon) { // this method also hide parent command line window ShowWindow(hcon, SW_HIDE); } else { HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE); CloseHandle(h); FreeConsole(); } #endif } #ifndef WIN32 /* Always catch Ctrl+C */ signal(SIGINT, signal_handler); #else SetConsoleCtrlHandler((PHANDLER_ROUTINE)ConsoleHandler, TRUE); if (opt_priority > 0) { DWORD prio = NORMAL_PRIORITY_CLASS; switch (opt_priority) { case 1: prio = BELOW_NORMAL_PRIORITY_CLASS; break; case 2: prio = NORMAL_PRIORITY_CLASS; break; case 3: prio = ABOVE_NORMAL_PRIORITY_CLASS; break; case 4: prio = HIGH_PRIORITY_CLASS; break; case 5: prio = REALTIME_PRIORITY_CLASS; } SetPriorityClass(GetCurrentProcess(), prio); } #endif if (opt_affinity != -1) { if (!opt_quiet) applog(LOG_DEBUG, "Binding process to cpu mask %x", opt_affinity); affine_to_cpu_mask(-1, (unsigned long)opt_affinity); } if (active_gpus == 0) { applog(LOG_ERR, "No CUDA devices found! terminating."); exit(1); } if (!opt_n_threads) opt_n_threads = active_gpus; else if (active_gpus > opt_n_threads) active_gpus = opt_n_threads; // generally doesn't work well... gpu_threads = max(gpu_threads, opt_n_threads / active_gpus); if (opt_benchmark && opt_algo == ALGO_AUTO) { bench_init(opt_n_threads); for (int n=0; n < MAX_GPUS; n++) { gpus_intensity[n] = 0; // use default } opt_autotune = false; } #ifdef HAVE_SYSLOG_H if (use_syslog) openlog(opt_syslog_pfx, LOG_PID, LOG_USER); #endif work_restart = (struct work_restart *)calloc(opt_n_threads, sizeof(*work_restart)); if (!work_restart) return EXIT_CODE_SW_INIT_ERROR; thr_info = (struct thr_info *)calloc(opt_n_threads + 4, sizeof(*thr)); if (!thr_info) return EXIT_CODE_SW_INIT_ERROR; /* longpoll thread */ longpoll_thr_id = opt_n_threads + 1; thr = &thr_info[longpoll_thr_id]; thr->id = longpoll_thr_id; thr->q = tq_new(); if (!thr->q) return EXIT_CODE_SW_INIT_ERROR; /* always start the longpoll thread (will wait a tq_push on workio /LP) */ if (unlikely(pthread_create(&thr->pth, NULL, longpoll_thread, thr))) { applog(LOG_ERR, "longpoll thread create failed"); return EXIT_CODE_SW_INIT_ERROR; } /* stratum thread */ stratum_thr_id = opt_n_threads + 2; thr = &thr_info[stratum_thr_id]; thr->id = stratum_thr_id; thr->q = tq_new(); if (!thr->q) return EXIT_CODE_SW_INIT_ERROR; /* always start the stratum thread (will wait a tq_push) */ if (unlikely(pthread_create(&thr->pth, NULL, stratum_thread, thr))) { applog(LOG_ERR, "stratum thread create failed"); return EXIT_CODE_SW_INIT_ERROR; } /* init workio thread */ work_thr_id = opt_n_threads; thr = &thr_info[work_thr_id]; thr->id = work_thr_id; thr->q = tq_new(); if (!thr->q) return EXIT_CODE_SW_INIT_ERROR; if (pthread_create(&thr->pth, NULL, workio_thread, thr)) { applog(LOG_ERR, "workio thread create failed"); return EXIT_CODE_SW_INIT_ERROR; } /* real start of the stratum work */ if (want_stratum && have_stratum) { tq_push(thr_info[stratum_thr_id].q, strdup(rpc_url)); } #ifdef USE_WRAPNVML #if defined(__linux__) || defined(_WIN64) /* nvml is currently not the best choice on Windows (only in x64) */ hnvml = nvml_create(); if (hnvml) { bool gpu_reinit = (opt_cudaschedule >= 0); //false cuda_devicenames(); // refresh gpu vendor name applog(LOG_INFO, "NVML GPU monitoring enabled."); for (int n=0; n < active_gpus; n++) { if (nvml_set_pstate(hnvml, device_map[n]) == 1) gpu_reinit = true; if (nvml_set_plimit(hnvml, device_map[n]) == 1) gpu_reinit = true; if (nvml_set_clocks(hnvml, device_map[n]) == 1) gpu_reinit = true; if (gpu_reinit) { cuda_reset_device(n, NULL); } } } #endif // force reinit to set default device flags if (opt_cudaschedule >= 0 && !hnvml) { for (int n=0; n < active_gpus; n++) { cuda_reset_device(n, NULL); } } #ifdef WIN32 if (!hnvml && nvapi_init() == 0) { applog(LOG_INFO, "NVAPI GPU monitoring enabled."); cuda_devicenames(); // refresh gpu vendor name } #endif else if (!hnvml) applog(LOG_INFO, "GPU monitoring is not available."); #endif if (opt_api_listen) { /* api thread */ api_thr_id = opt_n_threads + 3; thr = &thr_info[api_thr_id]; thr->id = api_thr_id; thr->q = tq_new(); if (!thr->q) return EXIT_CODE_SW_INIT_ERROR; /* start stratum thread */ if (unlikely(pthread_create(&thr->pth, NULL, api_thread, thr))) { applog(LOG_ERR, "api thread create failed"); return EXIT_CODE_SW_INIT_ERROR; } } /* start mining threads */ for (i = 0; i < opt_n_threads; i++) { thr = &thr_info[i]; thr->id = i; thr->gpu.thr_id = i; thr->gpu.gpu_id = (uint8_t) device_map[i]; thr->gpu.gpu_arch = (uint16_t) device_sm[device_map[i]]; thr->q = tq_new(); if (!thr->q) return EXIT_CODE_SW_INIT_ERROR; if (unlikely(pthread_create(&thr->pth, NULL, miner_thread, thr))) { applog(LOG_ERR, "thread %d create failed", i); return EXIT_CODE_SW_INIT_ERROR; } } applog(LOG_INFO, "%d miner thread%s started, " "using '%s' algorithm.", opt_n_threads, opt_n_threads > 1 ? "s":"", algo_names[opt_algo]); #ifdef WIN32 timeBeginPeriod(1); // enable high timer precision (similar to Google Chrome Trick) #endif /* main loop - simply wait for workio thread to exit */ pthread_join(thr_info[work_thr_id].pth, NULL); /* wait for mining threads */ for (i = 0; i < opt_n_threads; i++) pthread_join(thr_info[i].pth, NULL); if (opt_debug) applog(LOG_DEBUG, "workio thread dead, exiting."); proper_exit(EXIT_CODE_OK); return 0; }