OpenCL GPU miner
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

422 lines
8.6 KiB

/*
14 years ago
* Copyright 2010 Jeff Garzik
*
* 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/time.h>
#ifndef WIN32
#include <sys/resource.h>
#endif
#include <pthread.h>
#include <getopt.h>
#include <jansson.h>
#include "compat.h"
#include "miner.h"
#define PROGRAM_NAME "minerd"
#define DEF_RPC_URL "http://127.0.0.1:8332/"
#define DEF_RPC_USERPASS "rpcuser:rpcpass"
enum {
STAT_SLEEP_INTERVAL = 100,
STAT_CTR_INTERVAL = 10000000,
};
enum sha256_algos {
ALGO_C, /* plain C */
ALGO_4WAY, /* parallel SSE2 */
ALGO_VIA, /* VIA padlock */
ALGO_CRYPTOPP, /* Crypto++ */
};
static const char *algo_names[] = {
[ALGO_C] = "c",
#ifdef WANT_SSE2_4WAY
[ALGO_4WAY] = "4way",
#endif
#ifdef WANT_VIA_PADLOCK
[ALGO_VIA] = "via",
#endif
[ALGO_CRYPTOPP] = "cryptopp",
};
bool opt_debug = false;
bool opt_protocol = false;
static bool program_running = true;
static const bool opt_time = true;
static enum sha256_algos opt_algo = ALGO_C;
static int opt_n_threads = 1;
static char *rpc_url = DEF_RPC_URL;
static char *userpass = DEF_RPC_USERPASS;
struct option_help {
const char *name;
const char *helptext;
};
static struct option_help options_help[] = {
{ "help",
"(-h) Display this help text" },
{ "algo XXX",
"(-a XXX) Specify sha256 implementation:\n"
"\tc\t\tLinux kernel sha256, implemented in C (default)"
#ifdef WANT_SSE2_4WAY
"\n\t4way\t\ttcatm's 4-way SSE2 implementation"
#endif
#ifdef WANT_VIA_PADLOCK
"\n\tvia\t\tVIA padlock implementation (EXPERIMENTAL)"
#endif
"\n\tcryptopp\tCrypto++ library implementation (EXPERIMENTAL)"
},
{ "debug",
"(-D) Enable debug output (default: off)" },
{ "protocol-dump",
"(-P) Verbose dump of protocol-level activities (default: off)" },
{ "threads N",
"(-t N) Number of miner threads (default: 1)" },
{ "url URL",
"URL for bitcoin JSON-RPC server "
"(default: " DEF_RPC_URL ")" },
{ "userpass USERNAME:PASSWORD",
"Username:Password pair for bitcoin JSON-RPC server "
"(default: " DEF_RPC_USERPASS ")" },
};
static struct option options[] = {
{ "help", 0, NULL, 'h' },
{ "algo", 1, NULL, 'a' },
{ "debug", 0, NULL, 'D' },
{ "protocol-dump", 0, NULL, 'P' },
{ "threads", 1, NULL, 't' },
{ "url", 1, NULL, 1001 },
{ "userpass", 1, NULL, 1002 },
{ }
};
struct work {
unsigned char data[128];
unsigned char hash1[64];
unsigned char midstate[32];
unsigned char target[32];
unsigned char hash[32];
};
static bool jobj_binary(const json_t *obj, const char *key,
void *buf, size_t buflen)
{
const char *hexstr;
json_t *tmp;
tmp = json_object_get(obj, key);
if (!tmp) {
fprintf(stderr, "JSON key '%s' not found\n", key);
return false;
}
hexstr = json_string_value(tmp);
if (!hexstr) {
fprintf(stderr, "JSON key '%s' is not a string\n", key);
return false;
}
if (!hex2bin(buf, hexstr, buflen))
return false;
return true;
}
static bool work_decode(const json_t *val, struct work *work)
{
if (!jobj_binary(val, "midstate",
work->midstate, sizeof(work->midstate))) {
fprintf(stderr, "JSON inval midstate\n");
goto err_out;
}
if (!jobj_binary(val, "data", work->data, sizeof(work->data))) {
fprintf(stderr, "JSON inval data\n");
goto err_out;
}
if (!jobj_binary(val, "hash1", work->hash1, sizeof(work->hash1))) {
fprintf(stderr, "JSON inval hash1\n");
goto err_out;
}
if (!jobj_binary(val, "target", work->target, sizeof(work->target))) {
fprintf(stderr, "JSON inval target\n");
goto err_out;
}
memset(work->hash, 0, sizeof(work->hash));
return true;
err_out:
return false;
}
static void submit_work(struct work *work)
{
char *hexstr = NULL;
json_t *val, *res;
char s[345];
printf("PROOF OF WORK FOUND? submitting...\n");
/* build hex string */
hexstr = bin2hex(work->data, sizeof(work->data));
if (!hexstr)
goto out;
/* build JSON-RPC request */
sprintf(s,
"{\"method\": \"getwork\", \"params\": [ \"%s\" ], \"id\":1}\r\n",
hexstr);
if (opt_debug)
fprintf(stderr, "DBG: sending RPC call:\n%s", s);
/* issue JSON-RPC request */
val = json_rpc_call(rpc_url, userpass, s);
if (!val) {
fprintf(stderr, "submit_work json_rpc_call failed\n");
goto out;
}
res = json_object_get(val, "result");
printf("PROOF OF WORK RESULT: %s\n",
json_is_true(res) ? "true (yay!!!)" : "false (booooo)");
json_decref(val);
out:
free(hexstr);
}
static void hashmeter(int thr_id, struct timeval *tv_start,
unsigned long hashes_done)
{
struct timeval tv_end, diff;
double khashes, secs;
gettimeofday(&tv_end, NULL);
timeval_subtract(&diff, &tv_end, tv_start);
khashes = hashes_done / 1000.0;
secs = (double)diff.tv_sec + ((double)diff.tv_usec / 1000000.0);
printf("HashMeter(%d): %lu hashes, %.2f khash/sec\n",
thr_id, hashes_done,
khashes / secs);
}
static void *miner_thread(void *thr_id_int)
{
int thr_id = (unsigned long) thr_id_int;
static const char *rpc_req =
"{\"method\": \"getwork\", \"params\": [], \"id\":0}\r\n";
while (1) {
struct work work __attribute__((aligned(128)));
unsigned long hashes_done;
struct timeval tv_start;
json_t *val;
bool rc;
/* obtain new work from bitcoin */
val = json_rpc_call(rpc_url, userpass, rpc_req);
if (!val) {
fprintf(stderr, "json_rpc_call failed\n");
return NULL;
}
/* decode result into work state struct */
rc = work_decode(json_object_get(val, "result"), &work);
if (!rc) {
fprintf(stderr, "work decode failed\n");
return NULL;
}
json_decref(val);
hashes_done = 0;
gettimeofday(&tv_start, NULL);
/* scan nonces for a proof-of-work hash */
switch (opt_algo) {
case ALGO_C:
rc = scanhash_c(work.midstate, work.data + 64,
work.hash1, work.hash, &hashes_done);
break;
#ifdef WANT_SSE2_4WAY
case ALGO_4WAY: {
unsigned int rc4 =
ScanHash_4WaySSE2(work.midstate, work.data + 64,
work.hash1, work.hash,
&hashes_done);
rc = (rc4 == -1) ? false : true;
}
break;
#endif
#ifdef WANT_VIA_PADLOCK
case ALGO_VIA:
rc = scanhash_via(work.midstate, work.data + 64,
work.hash1, work.hash,
&hashes_done);
break;
#endif
case ALGO_CRYPTOPP:
rc = scanhash_cryptopp(work.midstate, work.data + 64,
work.hash1, work.hash, &hashes_done);
break;
}
hashmeter(thr_id, &tv_start, hashes_done);
/* if nonce found, submit work */
if (rc)
submit_work(&work);
}
return NULL;
}
static void show_usage(void)
{
int i;
printf("Usage:\tminerd [options]\n\nSupported options:\n");
for (i = 0; i < ARRAY_SIZE(options_help); i++) {
struct option_help *h;
h = &options_help[i];
printf("--%s\n%s\n\n", h->name, h->helptext);
}
exit(1);
}
static void parse_arg (int key, char *arg)
{
int v, i;
switch(key) {
case 'a':
for (i = 0; i < ARRAY_SIZE(algo_names); i++) {
if (algo_names[i] &&
!strcmp(arg, algo_names[i])) {
opt_algo = i;
break;
}
}
if (i == ARRAY_SIZE(algo_names))
show_usage();
break;
case 'D':
opt_debug = true;
break;
case 'P':
opt_protocol = true;
break;
case 't':
v = atoi(arg);
if (v < 1 || v > 9999) /* sanity check */
show_usage();
opt_n_threads = v;
break;
case 1001: /* --url */
if (strncmp(arg, "http://", 7) &&
strncmp(arg, "https://", 8))
show_usage();
rpc_url = arg;
break;
case 1002: /* --userpass */
if (!strchr(arg, ':'))
show_usage();
userpass = arg;
break;
default:
show_usage();
}
}
static void parse_cmdline(int argc, char *argv[])
{
int key;
while (1) {
key = getopt_long(argc, argv, "a:DPt:h?", options, NULL);
if (key < 0)
break;
parse_arg(key, optarg);
}
}
int main (int argc, char *argv[])
{
int i;
/* parse command line */
parse_cmdline(argc, argv);
/* set our priority to the highest (aka "nicest, least intrusive") */
if (setpriority(PRIO_PROCESS, 0, 19))
perror("setpriority");
/* start mining threads */
for (i = 0; i < opt_n_threads; i++) {
pthread_t t;
if (pthread_create(&t, NULL, miner_thread,
(void *)(unsigned long) i)) {
fprintf(stderr, "thread %d create failed\n", i);
return 1;
}
sleep(1); /* don't pound RPC server all at once */
}
fprintf(stderr, "%d miner threads started, "
"using SHA256 '%s' algorithm.\n",
opt_n_threads,
algo_names[opt_algo]);
/* main loop */
while (program_running) {
sleep(STAT_SLEEP_INTERVAL);
/* do nothing */
}
return 0;
}