2014-04-26 23:26:08 +00:00
|
|
|
#ifndef __MINER_H__
|
|
|
|
|
#define __MINER_H__
|
|
|
|
|
|
|
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
|
|
|
|
#endif
|
|
|
|
|
|
2016-05-26 04:00:48 +00:00
|
|
|
#include <ccminer-config.h>
|
2014-04-26 23:26:08 +00:00
|
|
|
|
|
|
|
|
#include <stdbool.h>
|
|
|
|
|
#include <inttypes.h>
|
|
|
|
|
#include <sys/time.h>
|
|
|
|
|
#include <pthread.h>
|
|
|
|
|
#include <jansson.h>
|
|
|
|
|
#include <curl/curl.h>
|
|
|
|
|
|
2015-02-09 14:17:05 +00:00
|
|
|
#ifdef _MSC_VER
|
2014-08-15 01:56:49 +00:00
|
|
|
#undef HAVE_ALLOCA_H
|
|
|
|
|
#undef HAVE_SYSLOG_H
|
2014-04-26 23:26:08 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef STDC_HEADERS
|
|
|
|
|
# include <stdlib.h>
|
|
|
|
|
# include <stddef.h>
|
|
|
|
|
#else
|
|
|
|
|
# ifdef HAVE_STDLIB_H
|
|
|
|
|
# include <stdlib.h>
|
|
|
|
|
# endif
|
|
|
|
|
#endif
|
2014-08-15 01:56:49 +00:00
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
#ifdef HAVE_ALLOCA_H
|
|
|
|
|
# include <alloca.h>
|
|
|
|
|
#elif !defined alloca
|
|
|
|
|
# ifdef __GNUC__
|
|
|
|
|
# define alloca __builtin_alloca
|
|
|
|
|
# elif defined _AIX
|
|
|
|
|
# define alloca __alloca
|
|
|
|
|
# elif defined _MSC_VER
|
|
|
|
|
# include <malloc.h>
|
|
|
|
|
# define alloca _alloca
|
|
|
|
|
# elif !defined HAVE_ALLOCA
|
|
|
|
|
void *alloca (size_t);
|
|
|
|
|
# endif
|
|
|
|
|
#endif
|
|
|
|
|
|
2015-01-24 10:25:45 +00:00
|
|
|
#include "compat.h"
|
|
|
|
|
|
2014-11-11 19:19:29 +00:00
|
|
|
#ifdef __INTELLISENSE__
|
|
|
|
|
/* should be in stdint.h but... */
|
|
|
|
|
typedef __int64 int64_t;
|
|
|
|
|
typedef unsigned __int64 uint64_t;
|
|
|
|
|
typedef __int32 int32_t;
|
|
|
|
|
typedef unsigned __int32 uint32_t;
|
|
|
|
|
typedef __int16 int16_t;
|
|
|
|
|
typedef unsigned __int16 uint16_t;
|
|
|
|
|
typedef __int16 int8_t;
|
|
|
|
|
typedef unsigned __int16 uint8_t;
|
|
|
|
|
|
|
|
|
|
typedef unsigned __int32 time_t;
|
|
|
|
|
typedef char * va_list;
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-11-03 15:06:49 +00:00
|
|
|
#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ > 0
|
2015-02-09 14:17:05 +00:00
|
|
|
# undef _ALIGN
|
2014-11-03 15:06:49 +00:00
|
|
|
# define _ALIGN(x) __align__(x)
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
#ifdef HAVE_SYSLOG_H
|
|
|
|
|
#include <syslog.h>
|
2016-06-21 06:51:23 +00:00
|
|
|
#define LOG_BLUE 0x10
|
|
|
|
|
#define LOG_RAW 0x99
|
2014-04-26 23:26:08 +00:00
|
|
|
#else
|
|
|
|
|
enum {
|
|
|
|
|
LOG_ERR,
|
|
|
|
|
LOG_WARNING,
|
|
|
|
|
LOG_NOTICE,
|
|
|
|
|
LOG_INFO,
|
|
|
|
|
LOG_DEBUG,
|
2014-08-07 05:37:29 +00:00
|
|
|
/* custom notices */
|
|
|
|
|
LOG_BLUE = 0x10,
|
2016-06-21 06:51:23 +00:00
|
|
|
LOG_RAW = 0x99
|
2014-04-26 23:26:08 +00:00
|
|
|
};
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-11-04 08:23:18 +00:00
|
|
|
typedef unsigned char uchar;
|
|
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
#undef unlikely
|
|
|
|
|
#undef likely
|
|
|
|
|
#if defined(__GNUC__) && (__GNUC__ > 2) && defined(__OPTIMIZE__)
|
|
|
|
|
#define unlikely(expr) (__builtin_expect(!!(expr), 0))
|
|
|
|
|
#define likely(expr) (__builtin_expect(!!(expr), 1))
|
|
|
|
|
#else
|
|
|
|
|
#define unlikely(expr) (expr)
|
|
|
|
|
#define likely(expr) (expr)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef ARRAY_SIZE
|
|
|
|
|
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-11-16 23:10:13 +00:00
|
|
|
#ifndef max
|
|
|
|
|
# define max(a, b) ((a) > (b) ? (a) : (b))
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef min
|
|
|
|
|
# define min(a, b) ((a) < (b) ? (a) : (b))
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-11-17 17:52:13 +00:00
|
|
|
#ifndef UINT32_MAX
|
|
|
|
|
/* for gcc 4.4 */
|
|
|
|
|
#define UINT32_MAX UINT_MAX
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-11-25 18:42:06 +00:00
|
|
|
static inline bool is_windows(void) {
|
|
|
|
|
#ifdef WIN32
|
|
|
|
|
return 1;
|
|
|
|
|
#else
|
|
|
|
|
return 0;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
#if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
|
|
|
|
|
#define WANT_BUILTIN_BSWAP
|
|
|
|
|
#else
|
|
|
|
|
#define bswap_32(x) ((((x) << 24) & 0xff000000u) | (((x) << 8) & 0x00ff0000u) \
|
|
|
|
|
| (((x) >> 8) & 0x0000ff00u) | (((x) >> 24) & 0x000000ffu))
|
2014-09-30 07:37:11 +00:00
|
|
|
#define bswap_64(x) (((uint64_t) bswap_32((uint32_t)((x) & 0xffffffffu)) << 32) \
|
|
|
|
|
| (uint64_t) bswap_32((uint32_t)((x) >> 32)))
|
2014-04-26 23:26:08 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static inline uint32_t swab32(uint32_t v)
|
|
|
|
|
{
|
|
|
|
|
#ifdef WANT_BUILTIN_BSWAP
|
|
|
|
|
return __builtin_bswap32(v);
|
|
|
|
|
#else
|
|
|
|
|
return bswap_32(v);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-30 07:37:11 +00:00
|
|
|
static inline uint64_t swab64(uint64_t v)
|
|
|
|
|
{
|
|
|
|
|
#ifdef WANT_BUILTIN_BSWAP
|
|
|
|
|
return __builtin_bswap64(v);
|
|
|
|
|
#else
|
|
|
|
|
return bswap_64(v);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void swab256(void *dest_p, const void *src_p)
|
|
|
|
|
{
|
|
|
|
|
uint32_t *dest = (uint32_t *) dest_p;
|
|
|
|
|
const uint32_t *src = (const uint32_t *) src_p;
|
|
|
|
|
|
|
|
|
|
dest[0] = swab32(src[7]);
|
|
|
|
|
dest[1] = swab32(src[6]);
|
|
|
|
|
dest[2] = swab32(src[5]);
|
|
|
|
|
dest[3] = swab32(src[4]);
|
|
|
|
|
dest[4] = swab32(src[3]);
|
|
|
|
|
dest[5] = swab32(src[2]);
|
|
|
|
|
dest[6] = swab32(src[1]);
|
|
|
|
|
dest[7] = swab32(src[0]);
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
#ifdef HAVE_SYS_ENDIAN_H
|
|
|
|
|
#include <sys/endian.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !HAVE_DECL_BE32DEC
|
|
|
|
|
static inline uint32_t be32dec(const void *pp)
|
|
|
|
|
{
|
|
|
|
|
const uint8_t *p = (uint8_t const *)pp;
|
|
|
|
|
return ((uint32_t)(p[3]) + ((uint32_t)(p[2]) << 8) +
|
|
|
|
|
((uint32_t)(p[1]) << 16) + ((uint32_t)(p[0]) << 24));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !HAVE_DECL_LE32DEC
|
|
|
|
|
static inline uint32_t le32dec(const void *pp)
|
|
|
|
|
{
|
|
|
|
|
const uint8_t *p = (uint8_t const *)pp;
|
|
|
|
|
return ((uint32_t)(p[0]) + ((uint32_t)(p[1]) << 8) +
|
|
|
|
|
((uint32_t)(p[2]) << 16) + ((uint32_t)(p[3]) << 24));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !HAVE_DECL_BE32ENC
|
|
|
|
|
static inline void be32enc(void *pp, uint32_t x)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *p = (uint8_t *)pp;
|
|
|
|
|
p[3] = x & 0xff;
|
|
|
|
|
p[2] = (x >> 8) & 0xff;
|
|
|
|
|
p[1] = (x >> 16) & 0xff;
|
|
|
|
|
p[0] = (x >> 24) & 0xff;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !HAVE_DECL_LE32ENC
|
|
|
|
|
static inline void le32enc(void *pp, uint32_t x)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *p = (uint8_t *)pp;
|
|
|
|
|
p[0] = x & 0xff;
|
|
|
|
|
p[1] = (x >> 8) & 0xff;
|
|
|
|
|
p[2] = (x >> 16) & 0xff;
|
|
|
|
|
p[3] = (x >> 24) & 0xff;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !HAVE_DECL_BE16DEC
|
|
|
|
|
static inline uint16_t be16dec(const void *pp)
|
|
|
|
|
{
|
|
|
|
|
const uint8_t *p = (uint8_t const *)pp;
|
|
|
|
|
return ((uint16_t)(p[1]) + ((uint16_t)(p[0]) << 8));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !HAVE_DECL_BE16ENC
|
|
|
|
|
static inline void be16enc(void *pp, uint16_t x)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *p = (uint8_t *)pp;
|
|
|
|
|
p[1] = x & 0xff;
|
|
|
|
|
p[0] = (x >> 8) & 0xff;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !HAVE_DECL_LE16DEC
|
|
|
|
|
static inline uint16_t le16dec(const void *pp)
|
|
|
|
|
{
|
|
|
|
|
const uint8_t *p = (uint8_t const *)pp;
|
|
|
|
|
return ((uint16_t)(p[0]) + ((uint16_t)(p[1]) << 8));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#if !HAVE_DECL_LE16ENC
|
|
|
|
|
static inline void le16enc(void *pp, uint16_t x)
|
|
|
|
|
{
|
|
|
|
|
uint8_t *p = (uint8_t *)pp;
|
|
|
|
|
p[0] = x & 0xff;
|
|
|
|
|
p[1] = (x >> 8) & 0xff;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-11-03 15:06:49 +00:00
|
|
|
/* used for struct work */
|
|
|
|
|
void *aligned_calloc(int size);
|
|
|
|
|
void aligned_free(void *ptr);
|
|
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
#if JANSSON_MAJOR_VERSION >= 2
|
|
|
|
|
#define JSON_LOADS(str, err_ptr) json_loads((str), 0, (err_ptr))
|
2015-08-24 06:40:37 +00:00
|
|
|
#define JSON_LOADF(str, err_ptr) json_load_file((str), 0, (err_ptr))
|
2014-04-26 23:26:08 +00:00
|
|
|
#else
|
|
|
|
|
#define JSON_LOADS(str, err_ptr) json_loads((str), (err_ptr))
|
2015-08-24 06:40:37 +00:00
|
|
|
#define JSON_LOADF(str, err_ptr) json_load_file((str), (err_ptr))
|
2014-04-26 23:26:08 +00:00
|
|
|
#endif
|
|
|
|
|
|
2015-08-24 06:40:37 +00:00
|
|
|
json_t * json_load_url(char* cfg_url, json_error_t *err);
|
|
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
#define USER_AGENT PACKAGE_NAME "/" PACKAGE_VERSION
|
|
|
|
|
|
|
|
|
|
void sha256_init(uint32_t *state);
|
|
|
|
|
void sha256_transform(uint32_t *state, const uint32_t *block, int swap);
|
|
|
|
|
void sha256d(unsigned char *hash, const unsigned char *data, int len);
|
|
|
|
|
|
|
|
|
|
#define HAVE_SHA256_4WAY 0
|
|
|
|
|
#define HAVE_SHA256_8WAY 0
|
|
|
|
|
|
2015-06-12 03:13:14 +00:00
|
|
|
struct work;
|
|
|
|
|
|
2015-09-23 09:56:47 +00:00
|
|
|
extern int scanhash_blake256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done, int8_t blakerounds);
|
2016-03-09 22:58:47 +00:00
|
|
|
extern int scanhash_blake2s(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
2015-09-23 09:56:47 +00:00
|
|
|
extern int scanhash_bmw(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_c11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
2016-02-06 08:40:14 +00:00
|
|
|
extern int scanhash_decred(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
2015-09-23 09:56:47 +00:00
|
|
|
extern int scanhash_deep(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_keccak256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_fresh(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_fugue256(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_groestlcoin(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_heavy(int thr_id,struct work *work, uint32_t max_nonce, unsigned long *hashes_done, uint32_t maxvote, int blocklen);
|
|
|
|
|
extern int scanhash_jackpot(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
2016-07-11 21:26:23 +00:00
|
|
|
extern int scanhash_lbry(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
2015-09-23 09:56:47 +00:00
|
|
|
extern int scanhash_luffa(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_lyra2(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_lyra2v2(int thr_id,struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_myriad(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_neoscrypt(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_nist5(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_pentablake(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_quark(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_qubit(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
2016-07-29 14:09:33 +00:00
|
|
|
extern int scanhash_sia(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
2015-12-31 05:03:16 +00:00
|
|
|
extern int scanhash_sib(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
2015-09-23 09:56:47 +00:00
|
|
|
extern int scanhash_skeincoin(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_skein2(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_s3(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
2016-02-18 08:19:25 +00:00
|
|
|
extern int scanhash_vanilla(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done, int8_t blake_rounds);
|
2016-08-18 12:53:21 +00:00
|
|
|
extern int scanhash_veltor(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
2015-10-06 21:01:39 +00:00
|
|
|
extern int scanhash_whirl(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
2016-05-31 17:40:23 +00:00
|
|
|
extern int scanhash_x11evo(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
2015-09-23 09:56:47 +00:00
|
|
|
extern int scanhash_x11(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_x13(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_x14(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_x15(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_x17(int thr_id, struct work* work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_zr5(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
|
|
|
|
|
extern int scanhash_sha256d(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done);
|
|
|
|
|
extern int scanhash_scrypt(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done,
|
|
|
|
|
unsigned char *scratchbuf, struct timeval *tv_start, struct timeval *tv_end);
|
|
|
|
|
extern int scanhash_scrypt_jane(int thr_id, struct work *work, uint32_t max_nonce, unsigned long *hashes_done,
|
|
|
|
|
unsigned char *scratchbuf, struct timeval *tv_start, struct timeval *tv_end);
|
2015-03-27 10:21:13 +00:00
|
|
|
|
2015-09-25 05:51:09 +00:00
|
|
|
/* free device allocated memory per algo */
|
2015-10-15 06:33:55 +00:00
|
|
|
void algo_free_all(int thr_id);
|
2015-09-25 05:51:09 +00:00
|
|
|
|
|
|
|
|
extern void free_blake256(int thr_id);
|
2016-03-09 22:58:47 +00:00
|
|
|
extern void free_blake2s(int thr_id);
|
2015-09-25 05:51:09 +00:00
|
|
|
extern void free_bmw(int thr_id);
|
|
|
|
|
extern void free_c11(int thr_id);
|
2016-02-06 08:40:14 +00:00
|
|
|
extern void free_decred(int thr_id);
|
2015-09-25 05:51:09 +00:00
|
|
|
extern void free_deep(int thr_id);
|
|
|
|
|
extern void free_keccak256(int thr_id);
|
|
|
|
|
extern void free_fresh(int thr_id);
|
|
|
|
|
extern void free_fugue256(int thr_id);
|
|
|
|
|
extern void free_groestlcoin(int thr_id);
|
|
|
|
|
extern void free_heavy(int thr_id);
|
|
|
|
|
extern void free_jackpot(int thr_id);
|
2016-07-29 14:09:33 +00:00
|
|
|
extern void free_lbry(int thr_id);
|
2015-09-25 05:51:09 +00:00
|
|
|
extern void free_luffa(int thr_id);
|
|
|
|
|
extern void free_lyra2(int thr_id);
|
|
|
|
|
extern void free_lyra2v2(int thr_id);
|
|
|
|
|
extern void free_myriad(int thr_id);
|
|
|
|
|
extern void free_neoscrypt(int thr_id);
|
|
|
|
|
extern void free_nist5(int thr_id);
|
|
|
|
|
extern void free_pentablake(int thr_id);
|
|
|
|
|
extern void free_quark(int thr_id);
|
|
|
|
|
extern void free_qubit(int thr_id);
|
2016-07-29 14:09:33 +00:00
|
|
|
extern void free_sia(int thr_id);
|
2015-12-31 05:03:16 +00:00
|
|
|
extern void free_sib(int thr_id);
|
2015-09-25 05:51:09 +00:00
|
|
|
extern void free_skeincoin(int thr_id);
|
|
|
|
|
extern void free_skein2(int thr_id);
|
|
|
|
|
extern void free_s3(int thr_id);
|
2016-02-18 08:19:25 +00:00
|
|
|
extern void free_vanilla(int thr_id);
|
2016-08-18 12:53:21 +00:00
|
|
|
extern void free_veltor(int thr_id);
|
2015-10-06 21:01:39 +00:00
|
|
|
extern void free_whirl(int thr_id);
|
2016-05-31 17:40:23 +00:00
|
|
|
extern void free_x11evo(int thr_id);
|
2015-09-25 05:51:09 +00:00
|
|
|
extern void free_x11(int thr_id);
|
|
|
|
|
extern void free_x13(int thr_id);
|
|
|
|
|
extern void free_x14(int thr_id);
|
|
|
|
|
extern void free_x15(int thr_id);
|
|
|
|
|
extern void free_x17(int thr_id);
|
|
|
|
|
extern void free_zr5(int thr_id);
|
|
|
|
|
//extern void free_sha256d(int thr_id);
|
|
|
|
|
extern void free_scrypt(int thr_id);
|
|
|
|
|
extern void free_scrypt_jane(int thr_id);
|
|
|
|
|
|
2014-11-12 10:43:55 +00:00
|
|
|
/* api related */
|
|
|
|
|
void *api_thread(void *userdata);
|
2015-01-24 09:43:58 +00:00
|
|
|
void api_set_throughput(int thr_id, uint32_t throughput);
|
2014-11-12 10:43:55 +00:00
|
|
|
|
|
|
|
|
struct cgpu_info {
|
2014-11-17 17:52:13 +00:00
|
|
|
uint8_t gpu_id;
|
|
|
|
|
uint8_t thr_id;
|
2014-11-12 10:43:55 +00:00
|
|
|
int accepted;
|
|
|
|
|
int rejected;
|
|
|
|
|
int hw_errors;
|
|
|
|
|
double khashes;
|
2016-09-27 21:20:28 +00:00
|
|
|
int has_monitoring;
|
2014-11-13 13:11:43 +00:00
|
|
|
float gpu_temp;
|
2014-12-26 14:33:11 +00:00
|
|
|
uint16_t gpu_fan;
|
|
|
|
|
uint16_t gpu_fan_rpm;
|
2014-11-26 04:22:35 +00:00
|
|
|
uint16_t gpu_arch;
|
2016-09-27 22:31:13 +00:00
|
|
|
uint32_t gpu_clock;
|
|
|
|
|
uint32_t gpu_memclock;
|
|
|
|
|
uint64_t gpu_mem;
|
|
|
|
|
uint64_t gpu_memfree;
|
2015-06-24 05:31:15 +00:00
|
|
|
uint32_t gpu_power;
|
2014-11-13 13:11:43 +00:00
|
|
|
double gpu_vddc;
|
2014-11-19 15:04:14 +00:00
|
|
|
int16_t gpu_pstate;
|
|
|
|
|
int16_t gpu_bus;
|
|
|
|
|
uint16_t gpu_vid;
|
|
|
|
|
uint16_t gpu_pid;
|
2014-11-23 10:06:14 +00:00
|
|
|
|
|
|
|
|
int8_t nvml_id;
|
|
|
|
|
int8_t nvapi_id;
|
|
|
|
|
|
2014-11-24 20:07:38 +00:00
|
|
|
char gpu_sn[64];
|
2014-11-19 15:04:14 +00:00
|
|
|
char gpu_desc[64];
|
2016-09-27 22:31:13 +00:00
|
|
|
double intensity;
|
2015-01-22 05:28:59 +00:00
|
|
|
uint32_t throughput;
|
2014-11-12 10:43:55 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct thr_api {
|
|
|
|
|
int id;
|
|
|
|
|
pthread_t pth;
|
|
|
|
|
struct thread_q *q;
|
|
|
|
|
};
|
2014-11-24 18:43:57 +00:00
|
|
|
|
|
|
|
|
struct stats_data {
|
2014-11-26 04:22:35 +00:00
|
|
|
uint32_t uid;
|
2014-11-24 18:43:57 +00:00
|
|
|
uint32_t tm_stat;
|
|
|
|
|
uint32_t hashcount;
|
|
|
|
|
uint32_t height;
|
2015-05-21 05:43:53 +00:00
|
|
|
|
2014-11-24 18:43:57 +00:00
|
|
|
double difficulty;
|
|
|
|
|
double hashrate;
|
2015-05-21 05:43:53 +00:00
|
|
|
|
2014-11-24 18:43:57 +00:00
|
|
|
uint8_t thr_id;
|
|
|
|
|
uint8_t gpu_id;
|
|
|
|
|
uint8_t hashfound;
|
|
|
|
|
uint8_t ignored;
|
2015-05-21 05:43:53 +00:00
|
|
|
|
|
|
|
|
uint8_t npool;
|
|
|
|
|
uint8_t pool_type;
|
|
|
|
|
uint16_t align;
|
2014-11-24 18:43:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct hashlog_data {
|
2015-05-21 05:43:53 +00:00
|
|
|
uint8_t npool;
|
|
|
|
|
uint8_t pool_type;
|
|
|
|
|
uint16_t align;
|
|
|
|
|
|
2014-11-24 18:43:57 +00:00
|
|
|
uint32_t height;
|
|
|
|
|
uint32_t njobid;
|
|
|
|
|
uint32_t nonce;
|
|
|
|
|
uint32_t scanned_from;
|
|
|
|
|
uint32_t scanned_to;
|
|
|
|
|
uint32_t last_from;
|
|
|
|
|
uint32_t tm_add;
|
|
|
|
|
uint32_t tm_upd;
|
2015-05-21 05:43:53 +00:00
|
|
|
uint32_t tm_sent;
|
2014-11-24 18:43:57 +00:00
|
|
|
};
|
|
|
|
|
|
2014-11-12 10:43:55 +00:00
|
|
|
/* end of api */
|
|
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
struct thr_info {
|
|
|
|
|
int id;
|
|
|
|
|
pthread_t pth;
|
|
|
|
|
struct thread_q *q;
|
2014-11-12 10:43:55 +00:00
|
|
|
struct cgpu_info gpu;
|
2014-04-26 23:26:08 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct work_restart {
|
2015-05-18 05:37:57 +00:00
|
|
|
/* volatile to modify accross threads (vstudio thing) */
|
|
|
|
|
volatile uint32_t restart;
|
|
|
|
|
char padding[128 - sizeof(uint32_t)];
|
2014-04-26 23:26:08 +00:00
|
|
|
};
|
|
|
|
|
|
2015-06-18 02:04:10 +00:00
|
|
|
#ifdef HAVE_GETOPT_LONG
|
|
|
|
|
#include <getopt.h>
|
|
|
|
|
#else
|
|
|
|
|
struct option {
|
|
|
|
|
const char *name;
|
|
|
|
|
int has_arg;
|
|
|
|
|
int *flag;
|
|
|
|
|
int val;
|
|
|
|
|
};
|
|
|
|
|
#endif
|
|
|
|
|
extern int options_count();
|
|
|
|
|
|
2014-09-06 19:54:46 +00:00
|
|
|
extern bool opt_benchmark;
|
2014-04-26 23:26:08 +00:00
|
|
|
extern bool opt_debug;
|
2014-09-03 11:53:01 +00:00
|
|
|
extern bool opt_quiet;
|
2014-04-26 23:26:08 +00:00
|
|
|
extern bool opt_protocol;
|
2015-09-23 06:47:39 +00:00
|
|
|
extern bool opt_showdiff;
|
2014-11-06 15:20:16 +00:00
|
|
|
extern bool opt_tracegpu;
|
2014-11-20 16:34:37 +00:00
|
|
|
extern int opt_n_threads;
|
2014-11-26 04:22:35 +00:00
|
|
|
extern int active_gpus;
|
2015-10-11 00:33:03 +00:00
|
|
|
extern int gpu_threads;
|
2014-04-26 23:26:08 +00:00
|
|
|
extern int opt_timeout;
|
|
|
|
|
extern bool want_longpoll;
|
|
|
|
|
extern bool have_longpoll;
|
|
|
|
|
extern bool want_stratum;
|
|
|
|
|
extern bool have_stratum;
|
2016-05-15 16:16:14 +00:00
|
|
|
extern bool opt_stratum_stats;
|
2014-04-26 23:26:08 +00:00
|
|
|
extern char *opt_cert;
|
|
|
|
|
extern char *opt_proxy;
|
|
|
|
|
extern long opt_proxy_type;
|
|
|
|
|
extern bool use_syslog;
|
2014-08-07 05:37:29 +00:00
|
|
|
extern bool use_colors;
|
2015-06-13 02:34:03 +00:00
|
|
|
extern int use_pok;
|
2014-04-26 23:26:08 +00:00
|
|
|
extern pthread_mutex_t applog_lock;
|
|
|
|
|
extern struct thr_info *thr_info;
|
|
|
|
|
extern int longpoll_thr_id;
|
|
|
|
|
extern int stratum_thr_id;
|
2014-11-12 10:43:55 +00:00
|
|
|
extern int api_thr_id;
|
2015-05-28 11:17:22 +00:00
|
|
|
extern volatile bool abort_flag;
|
2014-04-26 23:26:08 +00:00
|
|
|
extern struct work_restart *work_restart;
|
|
|
|
|
extern bool opt_trust_pool;
|
|
|
|
|
extern uint16_t opt_vote;
|
2014-11-14 15:35:10 +00:00
|
|
|
|
2014-09-29 06:17:55 +00:00
|
|
|
extern uint64_t global_hashrate;
|
2015-05-18 05:37:57 +00:00
|
|
|
extern uint64_t net_hashrate;
|
|
|
|
|
extern double net_diff;
|
|
|
|
|
extern double stratum_diff;
|
2014-04-26 23:26:08 +00:00
|
|
|
|
2015-01-22 03:34:30 +00:00
|
|
|
#define MAX_GPUS 16
|
2016-07-10 10:59:04 +00:00
|
|
|
//#define MAX_THREADS 32 todo
|
2015-01-22 03:34:30 +00:00
|
|
|
extern char* device_name[MAX_GPUS];
|
|
|
|
|
extern short device_map[MAX_GPUS];
|
|
|
|
|
extern long device_sm[MAX_GPUS];
|
2015-01-24 09:43:58 +00:00
|
|
|
extern uint32_t gpus_intensity[MAX_GPUS];
|
2015-09-17 21:39:55 +00:00
|
|
|
extern int opt_cudaschedule;
|
2014-11-26 04:22:35 +00:00
|
|
|
|
2015-10-10 22:53:54 +00:00
|
|
|
// cuda.cpp
|
2015-10-10 18:18:00 +00:00
|
|
|
int cuda_num_devices();
|
|
|
|
|
void cuda_devicenames();
|
|
|
|
|
void cuda_reset_device(int thr_id, bool *init);
|
|
|
|
|
void cuda_shutdown();
|
|
|
|
|
int cuda_finddevice(char *name);
|
2016-05-15 16:16:14 +00:00
|
|
|
int cuda_version();
|
2015-10-10 18:18:00 +00:00
|
|
|
void cuda_print_devices();
|
2016-07-10 10:59:04 +00:00
|
|
|
int cuda_gpu_info(struct cgpu_info *gpu);
|
2015-10-10 18:18:00 +00:00
|
|
|
int cuda_available_memory(int thr_id);
|
|
|
|
|
|
2015-10-11 00:33:03 +00:00
|
|
|
uint32_t cuda_default_throughput(int thr_id, uint32_t defcount);
|
2015-10-11 06:39:07 +00:00
|
|
|
#define device_intensity(t,f,d) cuda_default_throughput(t,d)
|
2016-09-26 21:53:56 +00:00
|
|
|
double throughput2intensity(uint32_t throughput);
|
2015-10-11 00:33:03 +00:00
|
|
|
|
2015-10-12 02:49:12 +00:00
|
|
|
void cuda_log_lasterror(int thr_id, const char* func, int line);
|
2015-11-02 16:51:56 +00:00
|
|
|
void cuda_clear_lasterror();
|
2015-10-12 02:49:12 +00:00
|
|
|
#define CUDA_LOG_ERROR() cuda_log_lasterror(thr_id, __func__, __LINE__)
|
|
|
|
|
|
2014-08-07 05:37:29 +00:00
|
|
|
#define CL_N "\x1B[0m"
|
|
|
|
|
#define CL_RED "\x1B[31m"
|
|
|
|
|
#define CL_GRN "\x1B[32m"
|
|
|
|
|
#define CL_YLW "\x1B[33m"
|
|
|
|
|
#define CL_BLU "\x1B[34m"
|
|
|
|
|
#define CL_MAG "\x1B[35m"
|
|
|
|
|
#define CL_CYN "\x1B[36m"
|
|
|
|
|
|
|
|
|
|
#define CL_BLK "\x1B[22;30m" /* black */
|
|
|
|
|
#define CL_RD2 "\x1B[22;31m" /* red */
|
|
|
|
|
#define CL_GR2 "\x1B[22;32m" /* green */
|
2014-09-04 18:04:55 +00:00
|
|
|
#define CL_YL2 "\x1B[22;33m" /* dark yellow */
|
2014-08-07 05:37:29 +00:00
|
|
|
#define CL_BL2 "\x1B[22;34m" /* blue */
|
|
|
|
|
#define CL_MA2 "\x1B[22;35m" /* magenta */
|
|
|
|
|
#define CL_CY2 "\x1B[22;36m" /* cyan */
|
|
|
|
|
#define CL_SIL "\x1B[22;37m" /* gray */
|
|
|
|
|
|
2014-12-07 11:49:40 +00:00
|
|
|
#ifdef WIN32
|
2014-08-07 05:37:29 +00:00
|
|
|
#define CL_GRY "\x1B[01;30m" /* dark gray */
|
2014-12-07 11:49:40 +00:00
|
|
|
#else
|
|
|
|
|
#define CL_GRY "\x1B[90m" /* dark gray selectable in putty */
|
|
|
|
|
#endif
|
2014-08-07 05:37:29 +00:00
|
|
|
#define CL_LRD "\x1B[01;31m" /* light red */
|
|
|
|
|
#define CL_LGR "\x1B[01;32m" /* light green */
|
2014-09-04 18:04:55 +00:00
|
|
|
#define CL_LYL "\x1B[01;33m" /* tooltips */
|
2014-08-07 05:37:29 +00:00
|
|
|
#define CL_LBL "\x1B[01;34m" /* light blue */
|
|
|
|
|
#define CL_LMA "\x1B[01;35m" /* light magenta */
|
|
|
|
|
#define CL_LCY "\x1B[01;36m" /* light cyan */
|
|
|
|
|
|
|
|
|
|
#define CL_WHT "\x1B[01;37m" /* white */
|
|
|
|
|
|
2015-02-21 15:02:28 +00:00
|
|
|
extern void format_hashrate(double hashrate, char *output);
|
2014-04-26 23:26:08 +00:00
|
|
|
extern void applog(int prio, const char *fmt, ...);
|
2015-10-11 07:59:39 +00:00
|
|
|
extern void gpulog(int prio, int thr_id, const char *fmt, ...);
|
2015-02-09 14:17:05 +00:00
|
|
|
void get_defconfig_path(char *out, size_t bufsize, char *argv0);
|
2014-09-28 13:16:18 +00:00
|
|
|
extern void cbin2hex(char *out, const char *in, size_t len);
|
|
|
|
|
extern char *bin2hex(const unsigned char *in, size_t len);
|
2016-02-06 08:40:14 +00:00
|
|
|
extern bool hex2bin(void *output, const char *hexstr, size_t len);
|
2014-04-26 23:26:08 +00:00
|
|
|
extern int timeval_subtract(struct timeval *result, struct timeval *x,
|
|
|
|
|
struct timeval *y);
|
|
|
|
|
extern bool fulltest(const uint32_t *hash, const uint32_t *target);
|
2015-10-06 21:08:47 +00:00
|
|
|
void diff_to_target(uint32_t* target, double diff);
|
|
|
|
|
void work_set_target(struct work* work, double diff);
|
2015-09-24 11:22:02 +00:00
|
|
|
double target_to_diff(uint32_t* target);
|
2014-11-13 13:11:43 +00:00
|
|
|
extern void get_currentalgo(char* buf, int sz);
|
2014-04-26 23:26:08 +00:00
|
|
|
|
2015-06-10 21:56:33 +00:00
|
|
|
// bignum
|
|
|
|
|
double bn_convert_nbits(const uint32_t nbits);
|
|
|
|
|
void bn_nbits_to_uchar(const uint32_t nBits, uchar *target);
|
2015-09-23 06:47:39 +00:00
|
|
|
double bn_hash_target_ratio(uint32_t* hash, uint32_t* target);
|
2016-09-27 07:03:24 +00:00
|
|
|
void bn_store_hash_target_ratio(uint32_t* hash, uint32_t* target, struct work* work, int nonce);
|
|
|
|
|
void bn_set_target_ratio(struct work* work, uint32_t* hash, int nonce);
|
2015-10-06 21:08:47 +00:00
|
|
|
void work_set_target_ratio(struct work* work, uint32_t* hash);
|
|
|
|
|
|
2015-10-10 18:18:00 +00:00
|
|
|
// bench
|
|
|
|
|
extern int bench_algo;
|
|
|
|
|
void bench_init(int threads);
|
|
|
|
|
void bench_free();
|
|
|
|
|
bool bench_algo_switch_next(int thr_id);
|
2015-10-11 00:33:03 +00:00
|
|
|
void bench_set_throughput(int thr_id, uint32_t throughput);
|
2015-10-10 18:18:00 +00:00
|
|
|
void bench_display_results();
|
2015-10-06 21:08:47 +00:00
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
struct stratum_job {
|
|
|
|
|
char *job_id;
|
|
|
|
|
unsigned char prevhash[32];
|
|
|
|
|
size_t coinbase_size;
|
|
|
|
|
unsigned char *coinbase;
|
|
|
|
|
unsigned char *xnonce2;
|
|
|
|
|
int merkle_count;
|
|
|
|
|
unsigned char **merkle;
|
|
|
|
|
unsigned char version[4];
|
|
|
|
|
unsigned char nbits[4];
|
|
|
|
|
unsigned char ntime[4];
|
2016-07-11 21:26:23 +00:00
|
|
|
unsigned char claim[32]; // lbry
|
2014-04-26 23:26:08 +00:00
|
|
|
bool clean;
|
|
|
|
|
unsigned char nreward[2];
|
2014-11-17 14:53:53 +00:00
|
|
|
uint32_t height;
|
2014-04-26 23:26:08 +00:00
|
|
|
double diff;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct stratum_ctx {
|
|
|
|
|
char *url;
|
|
|
|
|
|
|
|
|
|
CURL *curl;
|
|
|
|
|
char *curl_url;
|
|
|
|
|
char curl_err_str[CURL_ERROR_SIZE];
|
|
|
|
|
curl_socket_t sock;
|
|
|
|
|
size_t sockbuf_size;
|
|
|
|
|
char *sockbuf;
|
|
|
|
|
|
|
|
|
|
double next_diff;
|
2015-09-23 06:47:39 +00:00
|
|
|
double sharediff;
|
2014-04-26 23:26:08 +00:00
|
|
|
|
|
|
|
|
char *session_id;
|
|
|
|
|
size_t xnonce1_size;
|
|
|
|
|
unsigned char *xnonce1;
|
|
|
|
|
size_t xnonce2_size;
|
|
|
|
|
struct stratum_job job;
|
2014-09-03 10:54:13 +00:00
|
|
|
|
2014-11-25 16:09:07 +00:00
|
|
|
struct timeval tv_submit;
|
|
|
|
|
uint32_t answer_msec;
|
2015-05-21 05:43:53 +00:00
|
|
|
int pooln;
|
2014-11-25 16:09:07 +00:00
|
|
|
time_t tm_connected;
|
|
|
|
|
|
2014-09-03 10:54:13 +00:00
|
|
|
int srvtime_diff;
|
2014-11-17 14:53:53 +00:00
|
|
|
};
|
|
|
|
|
|
2015-06-13 02:34:03 +00:00
|
|
|
#define POK_MAX_TXS 4
|
|
|
|
|
#define POK_MAX_TX_SZ 16384U
|
2015-06-12 03:13:14 +00:00
|
|
|
struct tx {
|
|
|
|
|
uint8_t data[POK_MAX_TX_SZ];
|
|
|
|
|
uint32_t len;
|
|
|
|
|
};
|
|
|
|
|
|
2016-09-27 07:03:24 +00:00
|
|
|
#define MAX_NONCES 2
|
2014-11-17 14:53:53 +00:00
|
|
|
struct work {
|
2016-02-06 08:40:14 +00:00
|
|
|
uint32_t data[48];
|
2014-11-17 14:53:53 +00:00
|
|
|
uint32_t target[8];
|
|
|
|
|
uint32_t maxvote;
|
|
|
|
|
|
|
|
|
|
char job_id[128];
|
|
|
|
|
size_t xnonce2_len;
|
|
|
|
|
uchar xnonce2[32];
|
|
|
|
|
|
|
|
|
|
union {
|
|
|
|
|
uint32_t u32[2];
|
|
|
|
|
uint64_t u64[1];
|
|
|
|
|
} noncerange;
|
|
|
|
|
|
2016-09-27 07:03:24 +00:00
|
|
|
uint8_t pooln;
|
|
|
|
|
uint8_t valid_nonces;
|
2016-02-06 08:40:14 +00:00
|
|
|
|
2016-09-27 07:03:24 +00:00
|
|
|
uint32_t nonces[MAX_NONCES];
|
|
|
|
|
double sharediff[MAX_NONCES];
|
|
|
|
|
double shareratio[MAX_NONCES];
|
2015-09-23 06:47:39 +00:00
|
|
|
double targetdiff;
|
2016-09-27 07:03:24 +00:00
|
|
|
|
2014-11-17 14:53:53 +00:00
|
|
|
uint32_t height;
|
|
|
|
|
|
|
|
|
|
uint32_t scanned_from;
|
|
|
|
|
uint32_t scanned_to;
|
2015-06-12 03:13:14 +00:00
|
|
|
|
|
|
|
|
/* pok getwork txs */
|
|
|
|
|
uint32_t tx_count;
|
|
|
|
|
struct tx txs[POK_MAX_TXS];
|
2014-04-26 23:26:08 +00:00
|
|
|
};
|
|
|
|
|
|
2015-06-12 03:13:14 +00:00
|
|
|
#define POK_BOOL_MASK 0x00008000
|
|
|
|
|
#define POK_DATA_MASK 0xFFFF0000
|
|
|
|
|
|
2015-05-21 05:43:53 +00:00
|
|
|
#define MAX_POOLS 8
|
|
|
|
|
struct pool_infos {
|
|
|
|
|
uint8_t id;
|
|
|
|
|
#define POOL_UNUSED 0
|
|
|
|
|
#define POOL_GETWORK 1
|
|
|
|
|
#define POOL_STRATUM 2
|
|
|
|
|
#define POOL_LONGPOLL 4
|
|
|
|
|
uint8_t type;
|
|
|
|
|
#define POOL_ST_DEFINED 1
|
|
|
|
|
#define POOL_ST_VALID 2
|
|
|
|
|
#define POOL_ST_DISABLED 4
|
|
|
|
|
#define POOL_ST_REMOVED 8
|
|
|
|
|
uint16_t status;
|
2015-10-24 07:40:36 +00:00
|
|
|
int algo;
|
2015-05-21 05:43:53 +00:00
|
|
|
char name[64];
|
|
|
|
|
// credentials
|
2016-05-18 21:08:29 +00:00
|
|
|
char url[512];
|
2015-05-21 05:43:53 +00:00
|
|
|
char short_url[64];
|
2016-08-02 09:56:13 +00:00
|
|
|
char user[128];
|
2016-05-18 21:08:29 +00:00
|
|
|
char pass[384];
|
2015-05-21 05:43:53 +00:00
|
|
|
// config options
|
|
|
|
|
double max_diff;
|
|
|
|
|
double max_rate;
|
2016-05-17 19:24:49 +00:00
|
|
|
int shares_limit;
|
2015-05-21 05:43:53 +00:00
|
|
|
int time_limit;
|
|
|
|
|
int scantime;
|
|
|
|
|
// connection
|
|
|
|
|
struct stratum_ctx stratum;
|
|
|
|
|
uint8_t allow_gbt;
|
|
|
|
|
uint8_t allow_mininginfo;
|
|
|
|
|
uint16_t check_dups; // 16_t for align
|
|
|
|
|
int retries;
|
|
|
|
|
int fail_pause;
|
|
|
|
|
int timeout;
|
|
|
|
|
// stats
|
|
|
|
|
uint32_t work_time;
|
|
|
|
|
uint32_t wait_time;
|
|
|
|
|
uint32_t accepted_count;
|
|
|
|
|
uint32_t rejected_count;
|
2015-10-14 18:20:16 +00:00
|
|
|
uint32_t solved_count;
|
2016-02-23 23:41:23 +00:00
|
|
|
uint32_t stales_count;
|
2015-10-22 13:01:15 +00:00
|
|
|
time_t last_share_time;
|
|
|
|
|
double best_share;
|
2015-05-21 05:43:53 +00:00
|
|
|
uint32_t disconnects;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern struct pool_infos pools[MAX_POOLS];
|
|
|
|
|
extern int num_pools;
|
|
|
|
|
extern volatile int cur_pooln;
|
|
|
|
|
|
2015-06-18 02:04:10 +00:00
|
|
|
void pool_init_defaults(void);
|
2015-05-21 05:43:53 +00:00
|
|
|
void pool_set_creds(int pooln);
|
|
|
|
|
void pool_set_attr(int pooln, const char* key, char* arg);
|
|
|
|
|
bool pool_switch_url(char *params);
|
2015-10-24 07:40:36 +00:00
|
|
|
bool pool_switch(int thr_id, int pooln);
|
|
|
|
|
bool pool_switch_next(int thr_id);
|
2015-06-18 02:04:10 +00:00
|
|
|
int pool_get_first_valid(int startfrom);
|
|
|
|
|
bool parse_pool_array(json_t *obj);
|
|
|
|
|
void pool_dump_infos(void);
|
2015-05-21 05:43:53 +00:00
|
|
|
|
|
|
|
|
json_t * json_rpc_call_pool(CURL *curl, struct pool_infos*,
|
|
|
|
|
const char *req, bool lp_scan, bool lp, int *err);
|
|
|
|
|
json_t * json_rpc_longpoll(CURL *curl, char *lp_url, struct pool_infos*,
|
|
|
|
|
const char *req, int *err);
|
|
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
bool stratum_socket_full(struct stratum_ctx *sctx, int timeout);
|
|
|
|
|
bool stratum_send_line(struct stratum_ctx *sctx, char *s);
|
|
|
|
|
char *stratum_recv_line(struct stratum_ctx *sctx);
|
|
|
|
|
bool stratum_connect(struct stratum_ctx *sctx, const char *url);
|
|
|
|
|
void stratum_disconnect(struct stratum_ctx *sctx);
|
|
|
|
|
bool stratum_subscribe(struct stratum_ctx *sctx);
|
|
|
|
|
bool stratum_authorize(struct stratum_ctx *sctx, const char *user, const char *pass);
|
|
|
|
|
bool stratum_handle_method(struct stratum_ctx *sctx, const char *s);
|
2015-05-21 05:43:53 +00:00
|
|
|
void stratum_free_job(struct stratum_ctx *sctx);
|
2014-04-26 23:26:08 +00:00
|
|
|
|
2014-11-17 14:53:53 +00:00
|
|
|
void hashlog_remember_submit(struct work* work, uint32_t nonce);
|
|
|
|
|
void hashlog_remember_scan_range(struct work* work);
|
2014-09-02 03:09:31 +00:00
|
|
|
uint32_t hashlog_already_submittted(char* jobid, uint32_t nounce);
|
2014-09-02 10:40:52 +00:00
|
|
|
uint32_t hashlog_get_last_sent(char* jobid);
|
2014-09-03 19:05:15 +00:00
|
|
|
uint64_t hashlog_get_scan_range(char* jobid);
|
2014-11-24 18:43:57 +00:00
|
|
|
int hashlog_get_history(struct hashlog_data *data, int max_records);
|
2014-09-02 03:09:31 +00:00
|
|
|
void hashlog_purge_old(void);
|
|
|
|
|
void hashlog_purge_job(char* jobid);
|
|
|
|
|
void hashlog_purge_all(void);
|
2014-09-04 06:55:00 +00:00
|
|
|
void hashlog_dump_job(char* jobid);
|
2014-11-17 15:17:53 +00:00
|
|
|
void hashlog_getmeminfo(uint64_t *mem, uint32_t *records);
|
2014-09-02 03:09:31 +00:00
|
|
|
|
2014-11-18 15:05:30 +00:00
|
|
|
void stats_remember_speed(int thr_id, uint32_t hashcount, double hashrate, uint8_t found, uint32_t height);
|
2014-11-14 15:35:10 +00:00
|
|
|
double stats_get_speed(int thr_id, double def_speed);
|
2015-05-12 00:32:05 +00:00
|
|
|
double stats_get_gpu_speed(int gpu_id);
|
2014-11-14 15:35:10 +00:00
|
|
|
int stats_get_history(int thr_id, struct stats_data *data, int max_records);
|
2014-11-11 14:54:35 +00:00
|
|
|
void stats_purge_old(void);
|
|
|
|
|
void stats_purge_all(void);
|
2014-11-17 15:17:53 +00:00
|
|
|
void stats_getmeminfo(uint64_t *mem, uint32_t *records);
|
2014-11-11 14:54:35 +00:00
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
struct thread_q;
|
|
|
|
|
|
|
|
|
|
extern struct thread_q *tq_new(void);
|
|
|
|
|
extern void tq_free(struct thread_q *tq);
|
|
|
|
|
extern bool tq_push(struct thread_q *tq, void *data);
|
|
|
|
|
extern void *tq_pop(struct thread_q *tq, const struct timespec *abstime);
|
|
|
|
|
extern void tq_freeze(struct thread_q *tq);
|
|
|
|
|
extern void tq_thaw(struct thread_q *tq);
|
|
|
|
|
|
2015-04-19 10:04:04 +00:00
|
|
|
#define EXIT_CODE_OK 0
|
|
|
|
|
#define EXIT_CODE_USAGE 1
|
|
|
|
|
#define EXIT_CODE_POOL_TIMEOUT 2
|
|
|
|
|
#define EXIT_CODE_SW_INIT_ERROR 3
|
|
|
|
|
#define EXIT_CODE_CUDA_NODEVICE 4
|
|
|
|
|
#define EXIT_CODE_CUDA_ERROR 5
|
|
|
|
|
#define EXIT_CODE_TIME_LIMIT 0
|
|
|
|
|
#define EXIT_CODE_KILLED 7
|
|
|
|
|
|
2015-02-13 05:57:39 +00:00
|
|
|
void parse_arg(int key, char *arg);
|
2014-09-01 16:49:23 +00:00
|
|
|
void proper_exit(int reason);
|
2015-03-27 06:46:19 +00:00
|
|
|
void restart_threads(void);
|
2014-08-30 20:46:59 +00:00
|
|
|
|
2014-09-02 10:40:52 +00:00
|
|
|
size_t time2str(char* buf, time_t timer);
|
|
|
|
|
char* atime2str(time_t timer);
|
|
|
|
|
|
2016-02-06 08:40:14 +00:00
|
|
|
void applog_hex(void *data, int len);
|
|
|
|
|
void applog_hash(void *hash);
|
|
|
|
|
void applog_hash64(void *hash);
|
|
|
|
|
void applog_compare_hash(void *hash, void *hash_ref);
|
2014-08-30 20:46:59 +00:00
|
|
|
|
2014-08-08 06:06:06 +00:00
|
|
|
void print_hash_tests(void);
|
2014-09-12 21:28:19 +00:00
|
|
|
void blake256hash(void *output, const void *input, int8_t rounds);
|
2016-03-09 22:58:47 +00:00
|
|
|
void blake2s_hash(void *output, const void *input);
|
2015-08-22 13:01:51 +00:00
|
|
|
void bmw_hash(void *state, const void *input);
|
2015-06-29 08:49:09 +00:00
|
|
|
void c11hash(void *output, const void *input);
|
2016-02-06 08:40:14 +00:00
|
|
|
void decred_hash(void *state, const void *input);
|
2014-09-09 19:56:25 +00:00
|
|
|
void deephash(void *state, const void *input);
|
2015-06-10 19:57:20 +00:00
|
|
|
void luffa_hash(void *state, const void *input);
|
2014-09-01 06:44:19 +00:00
|
|
|
void fresh_hash(void *state, const void *input);
|
2014-08-14 17:49:31 +00:00
|
|
|
void fugue256_hash(unsigned char* output, const unsigned char* input, int len);
|
|
|
|
|
void heavycoin_hash(unsigned char* output, const unsigned char* input, int len);
|
2014-10-17 04:22:16 +00:00
|
|
|
void keccak256_hash(void *state, const void *input);
|
2014-09-01 06:44:19 +00:00
|
|
|
unsigned int jackpothash(void *state, const void *input);
|
2014-08-14 17:49:31 +00:00
|
|
|
void groestlhash(void *state, const void *input);
|
2016-07-11 21:26:23 +00:00
|
|
|
void lbry_hash(void *output, const void *input);
|
2015-08-18 07:27:11 +00:00
|
|
|
void lyra2re_hash(void *state, const void *input);
|
|
|
|
|
void lyra2v2_hash(void *state, const void *input);
|
2014-08-14 17:49:31 +00:00
|
|
|
void myriadhash(void *state, const void *input);
|
2015-05-03 12:52:10 +00:00
|
|
|
void neoscrypt(uchar *output, const uchar *input, uint32_t profile);
|
2014-08-18 01:45:48 +00:00
|
|
|
void nist5hash(void *state, const void *input);
|
2014-09-06 19:54:46 +00:00
|
|
|
void pentablakehash(void *output, const void *input);
|
2014-08-14 17:49:31 +00:00
|
|
|
void quarkhash(void *state, const void *input);
|
2014-09-09 19:56:25 +00:00
|
|
|
void qubithash(void *state, const void *input);
|
2015-04-18 06:08:23 +00:00
|
|
|
void scrypthash(void* output, const void* input);
|
2015-04-21 11:20:24 +00:00
|
|
|
void scryptjane_hash(void* output, const void* input);
|
2015-12-31 05:03:16 +00:00
|
|
|
void sibhash(void *output, const void *input);
|
2015-03-27 10:37:36 +00:00
|
|
|
void skeincoinhash(void *output, const void *input);
|
2015-04-13 23:46:11 +00:00
|
|
|
void skein2hash(void *output, const void *input);
|
2014-10-26 07:59:49 +00:00
|
|
|
void s3hash(void *output, const void *input);
|
2016-08-18 12:53:21 +00:00
|
|
|
void veltorhash(void *output, const void *input);
|
2015-10-06 21:01:39 +00:00
|
|
|
void wcoinhash(void *state, const void *input);
|
2015-08-15 04:46:32 +00:00
|
|
|
void whirlxHash(void *state, const void *input);
|
2016-05-31 17:40:23 +00:00
|
|
|
void x11evo_hash(void *output, const void *input);
|
2014-08-08 06:06:06 +00:00
|
|
|
void x11hash(void *output, const void *input);
|
|
|
|
|
void x13hash(void *output, const void *input);
|
|
|
|
|
void x14hash(void *output, const void *input);
|
|
|
|
|
void x15hash(void *output, const void *input);
|
2014-08-23 16:18:24 +00:00
|
|
|
void x17hash(void *output, const void *input);
|
2015-03-27 10:21:13 +00:00
|
|
|
void zr5hash(void *output, const void *input);
|
2015-03-28 11:01:50 +00:00
|
|
|
void zr5hash_pok(void *output, uint32_t *pdata);
|
2014-08-08 06:06:06 +00:00
|
|
|
|
2014-04-26 23:26:08 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#endif /* __MINER_H__ */
|
