Browse Source

klondike store and report errorcount and noise

nfactor-troky
Kano 11 years ago
parent
commit
2dc54366f9
  1. 151
      driver-klondike.c

151
driver-klondike.c

@ -64,6 +64,7 @@ typedef struct klondike_status {
uint8_t errorcount; uint8_t errorcount;
uint16_t hashcount; uint16_t hashcount;
uint16_t maxcount; uint16_t maxcount;
uint8_t noise;
} WORKSTATUS; } WORKSTATUS;
typedef struct _worktask { typedef struct _worktask {
@ -102,13 +103,15 @@ struct klondike_info {
bool shutdown; bool shutdown;
pthread_rwlock_t stat_lock; pthread_rwlock_t stat_lock;
struct thr_info replies_thr; struct thr_info replies_thr;
WORKSTATUS *status; WORKSTATUS *status;
DEVINFO *devinfo; DEVINFO *devinfo;
WORKCFG *cfg; WORKCFG *cfg;
char *replies; char *replies;
int nextreply; int nextreply;
int noncecount; int noncecount;
uint64_t hashcount; uint64_t hashcount;
uint64_t errorcount;
uint64_t noisecount;
}; };
IDENTITY KlondikeID; IDENTITY KlondikeID;
@ -131,7 +134,7 @@ static char *SendCmdGetReply(struct cgpu_info *klncgpu, char Cmd, int device, in
int retries = CMD_REPLY_RETRIES; int retries = CMD_REPLY_RETRIES;
int chkreply = klninfo->nextreply; int chkreply = klninfo->nextreply;
int sent, err; int sent, err;
if (klncgpu->usbinfo.nodev) if (klncgpu->usbinfo.nodev)
return NULL; return NULL;
@ -157,7 +160,7 @@ static char *SendCmdGetReply(struct cgpu_info *klncgpu, char Cmd, int device, in
} }
return NULL; return NULL;
} }
static bool klondike_get_stats(struct cgpu_info *klncgpu) static bool klondike_get_stats(struct cgpu_info *klncgpu)
{ {
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
@ -168,7 +171,7 @@ static bool klondike_get_stats(struct cgpu_info *klncgpu)
applog(LOG_DEBUG, "Klondike getting status"); applog(LOG_DEBUG, "Klondike getting status");
slaves = klninfo->status[0].slavecount; slaves = klninfo->status[0].slavecount;
// loop thru devices and get status for each // loop thru devices and get status for each
wr_lock(&(klninfo->stat_lock)); wr_lock(&(klninfo->stat_lock));
for (dev = 0; dev <= slaves; dev++) { for (dev = 0; dev <= slaves; dev++) {
@ -177,9 +180,9 @@ static bool klondike_get_stats(struct cgpu_info *klncgpu)
memcpy((void *)(&(klninfo->status[dev])), reply+2, sizeof(klninfo->status[dev])); memcpy((void *)(&(klninfo->status[dev])), reply+2, sizeof(klninfo->status[dev]));
} }
wr_unlock(&(klninfo->stat_lock)); wr_unlock(&(klninfo->stat_lock));
// todo: detect slavecount change and realloc space // todo: detect slavecount change and realloc space
return true; return true;
} }
@ -187,15 +190,15 @@ static bool klondike_init(struct cgpu_info *klncgpu)
{ {
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
int slaves, dev; int slaves, dev;
char *reply = SendCmdGetReply(klncgpu, 'S', 0, 0, NULL); char *reply = SendCmdGetReply(klncgpu, 'S', 0, 0, NULL);
if (reply == NULL) if (reply == NULL)
return false; return false;
slaves = ((WORKSTATUS *)(reply+2))->slavecount; slaves = ((WORKSTATUS *)(reply+2))->slavecount;
if (klninfo->status == NULL) { if (klninfo->status == NULL) {
applog(LOG_DEBUG, "Klondike initializing data"); applog(LOG_DEBUG, "Klondike initializing data");
// alloc space for status, devinfo and cfg for master and slaves // alloc space for status, devinfo and cfg for master and slaves
klninfo->status = calloc(slaves+1, sizeof(WORKSTATUS)); klninfo->status = calloc(slaves+1, sizeof(WORKSTATUS));
if (unlikely(!klninfo->status)) if (unlikely(!klninfo->status))
@ -207,27 +210,27 @@ static bool klondike_init(struct cgpu_info *klncgpu)
if (unlikely(!klninfo->cfg)) if (unlikely(!klninfo->cfg))
quit(1, "Failed to calloc cfg array in klondke_get_stats"); quit(1, "Failed to calloc cfg array in klondke_get_stats");
} }
WORKCFG cfgset = { 0,0,0,0,0 }; // zero init triggers read back only WORKCFG cfgset = { 0,0,0,0,0 }; // zero init triggers read back only
double temp1, temp2; double temp1, temp2;
int size = 2; int size = 2;
if (opt_klondike_options != NULL) { // boundaries are checked by device, with valid values returned if (opt_klondike_options != NULL) { // boundaries are checked by device, with valid values returned
sscanf(opt_klondike_options, "%hu:%lf:%lf:%hhu", &cfgset.hashclock, &temp1, &temp2, &cfgset.fantarget); sscanf(opt_klondike_options, "%hu:%lf:%lf:%hhu", &cfgset.hashclock, &temp1, &temp2, &cfgset.fantarget);
cfgset.temptarget = cvtCToKln(temp1); cfgset.temptarget = cvtCToKln(temp1);
cfgset.tempcritical = cvtCToKln(temp2); cfgset.tempcritical = cvtCToKln(temp2);
cfgset.fantarget = (int)255*cfgset.fantarget/100; cfgset.fantarget = (int)255*cfgset.fantarget/100;
size = sizeof(cfgset); size = sizeof(cfgset);
} }
for (dev = 0; dev <= slaves; dev++) { for (dev = 0; dev <= slaves; dev++) {
char *reply = SendCmdGetReply(klncgpu, 'C', dev, size, &cfgset); char *reply = SendCmdGetReply(klncgpu, 'C', dev, size, &cfgset);
if (reply != NULL) { if (reply != NULL) {
klninfo->cfg[dev] = *(WORKCFG *)(reply+2); klninfo->cfg[dev] = *(WORKCFG *)(reply+2);
applog(LOG_NOTICE, "Klondike config (%d: Clk: %d, T:%.0lf, C:%.0lf, F:%d)", applog(LOG_NOTICE, "Klondike config (%d: Clk: %d, T:%.0lf, C:%.0lf, F:%d)",
dev, klninfo->cfg[dev].hashclock, dev, klninfo->cfg[dev].hashclock,
cvtKlnToC(klninfo->cfg[dev].temptarget), cvtKlnToC(klninfo->cfg[dev].temptarget),
cvtKlnToC(klninfo->cfg[dev].tempcritical), cvtKlnToC(klninfo->cfg[dev].tempcritical),
(int)100*klninfo->cfg[dev].fantarget/256); (int)100*klninfo->cfg[dev].fantarget/256);
} }
} }
@ -236,9 +239,9 @@ static bool klondike_init(struct cgpu_info *klncgpu)
klninfo->devinfo[dev].rangesize = ((uint64_t)1<<32) / klninfo->status[dev].chipcount; klninfo->devinfo[dev].rangesize = ((uint64_t)1<<32) / klninfo->status[dev].chipcount;
klninfo->devinfo[dev].chipstats = calloc(klninfo->status[dev].chipcount*2 , sizeof(uint32_t)); klninfo->devinfo[dev].chipstats = calloc(klninfo->status[dev].chipcount*2 , sizeof(uint32_t));
} }
SendCmdGetReply(klncgpu, 'E', 0, 1, "1"); SendCmdGetReply(klncgpu, 'E', 0, 1, "1");
return true; return true;
} }
@ -249,23 +252,23 @@ static bool klondike_detect_one(struct libusb_device *dev, struct usb_find_devic
if (unlikely(!klncgpu)) if (unlikely(!klncgpu))
quit(1, "Failed to calloc klncgpu in klondike_detect_one"); quit(1, "Failed to calloc klncgpu in klondike_detect_one");
klninfo = calloc(1, sizeof(*klninfo)); klninfo = calloc(1, sizeof(*klninfo));
if (unlikely(!klninfo)) if (unlikely(!klninfo))
quit(1, "Failed to calloc klninfo in klondke_detect_one"); quit(1, "Failed to calloc klninfo in klondke_detect_one");
klncgpu->device_data = (FILE *)klninfo; klncgpu->device_data = (FILE *)klninfo;
klninfo->replies = calloc(MAX_REPLY_COUNT, REPLY_BUFSIZE); klninfo->replies = calloc(MAX_REPLY_COUNT, REPLY_BUFSIZE);
if (unlikely(!klninfo->replies)) if (unlikely(!klninfo->replies))
quit(1, "Failed to calloc replies buffer in klondke_detect_one"); quit(1, "Failed to calloc replies buffer in klondke_detect_one");
klninfo->nextreply = 0; klninfo->nextreply = 0;
if (usb_init(klncgpu, dev, found)) { if (usb_init(klncgpu, dev, found)) {
int attempts = 0; int attempts = 0;
while (attempts++ < 3) { while (attempts++ < 3) {
char devpath[20], reply[REPLY_SIZE]; char devpath[20], reply[REPLY_SIZE];
int sent, recd, err; int sent, recd, err;
sprintf(devpath, "%d:%d", (int)(klncgpu->usbinfo.bus_number), (int)(klncgpu->usbinfo.device_address)); sprintf(devpath, "%d:%d", (int)(klncgpu->usbinfo.bus_number), (int)(klncgpu->usbinfo.device_address));
err = usb_write(klncgpu, "I", 2, &sent, C_REQUESTRESULTS); err = usb_write(klncgpu, "I", 2, &sent, C_REQUESTRESULTS);
if (err < 0 || sent != 2) { if (err < 0 || sent != 2) {
@ -310,28 +313,28 @@ static void klondike_check_nonce(struct cgpu_info *klncgpu, WORKRESULT *result)
{ {
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
struct work *work, *tmp; struct work *work, *tmp;
applog(LOG_DEBUG, "Klondike FOUND NONCE (%02x:%08x)", result->workid, result->nonce); applog(LOG_DEBUG, "Klondike FOUND NONCE (%02x:%08x)", result->workid, result->nonce);
HASH_ITER(hh, klncgpu->queued_work, work, tmp) { HASH_ITER(hh, klncgpu->queued_work, work, tmp) {
if (work->queued && (work->subid == (result->device*256 + result->workid))) { if (work->queued && (work->subid == (result->device*256 + result->workid))) {
wr_lock(&(klninfo->stat_lock)); wr_lock(&(klninfo->stat_lock));
klninfo->devinfo[result->device].noncecount++; klninfo->devinfo[result->device].noncecount++;
klninfo->noncecount++; klninfo->noncecount++;
wr_unlock(&(klninfo->stat_lock)); wr_unlock(&(klninfo->stat_lock));
result->nonce = le32toh(result->nonce - 0xC0); result->nonce = le32toh(result->nonce - 0xC0);
applog(LOG_DEBUG, "Klondike SUBMIT NONCE (%02x:%08x)", result->workid, result->nonce); applog(LOG_DEBUG, "Klondike SUBMIT NONCE (%02x:%08x)", result->workid, result->nonce);
bool ok = submit_nonce(klncgpu->thr[0], work, result->nonce); bool ok = submit_nonce(klncgpu->thr[0], work, result->nonce);
applog(LOG_DEBUG, "Klondike chip stats %d, %08x, %d, %d", result->device, result->nonce, klninfo->devinfo[result->device].rangesize, klninfo->status[result->device].chipcount); applog(LOG_DEBUG, "Klondike chip stats %d, %08x, %d, %d", result->device, result->nonce, klninfo->devinfo[result->device].rangesize, klninfo->status[result->device].chipcount);
klninfo->devinfo[result->device].chipstats[(result->nonce / klninfo->devinfo[result->device].rangesize) + (ok ? 0 : klninfo->status[result->device].chipcount)]++; klninfo->devinfo[result->device].chipstats[(result->nonce / klninfo->devinfo[result->device].rangesize) + (ok ? 0 : klninfo->status[result->device].chipcount)]++;
return; return;
} }
} }
applog(LOG_ERR, "%s%i:%d unknown work (%02x:%08x) - ignored", applog(LOG_ERR, "%s%i:%d unknown work (%02x:%08x) - ignored",
klncgpu->drv->name, klncgpu->device_id, result->device, result->workid, result->nonce); klncgpu->drv->name, klncgpu->device_id, result->device, result->workid, result->nonce);
//inc_hw_errors(klncgpu->thr[0]); //inc_hw_errors(klncgpu->thr[0]);
} }
@ -341,18 +344,19 @@ static void *klondike_get_replies(void *userdata)
{ {
struct cgpu_info *klncgpu = (struct cgpu_info *)userdata; struct cgpu_info *klncgpu = (struct cgpu_info *)userdata;
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
struct klondike_status *ks;
char *replybuf; char *replybuf;
int err, recd; int err, recd;
applog(LOG_DEBUG, "Klondike listening for replies"); applog(LOG_DEBUG, "Klondike listening for replies");
while (klninfo->shutdown == false) { while (klninfo->shutdown == false) {
if (klncgpu->usbinfo.nodev) if (klncgpu->usbinfo.nodev)
return NULL; return NULL;
replybuf = klninfo->replies + klninfo->nextreply * REPLY_BUFSIZE; replybuf = klninfo->replies + klninfo->nextreply * REPLY_BUFSIZE;
replybuf[0] = 0; replybuf[0] = 0;
err = usb_read(klncgpu, replybuf+1, REPLY_SIZE, &recd, C_GETRESULTS); err = usb_read(klncgpu, replybuf+1, REPLY_SIZE, &recd, C_GETRESULTS);
if (!err && recd == REPLY_SIZE) { if (!err && recd == REPLY_SIZE) {
if (opt_log_level <= LOG_DEBUG) { if (opt_log_level <= LOG_DEBUG) {
@ -362,10 +366,25 @@ static void *klondike_get_replies(void *userdata)
} }
if (++klninfo->nextreply == MAX_REPLY_COUNT) if (++klninfo->nextreply == MAX_REPLY_COUNT)
klninfo->nextreply = 0; klninfo->nextreply = 0;
replybuf[0] = replybuf[1]; replybuf[0] = replybuf[1];
if (replybuf[0] == '=') switch (replybuf[0]) {
klondike_check_nonce(klncgpu, (WORKRESULT *)replybuf); case '=':
klondike_check_nonce(klncgpu, (WORKRESULT *)replybuf);
break;
case 'S':
case 'W':
case 'A':
case 'E':
ks = (struct klondike_status *)(replybuf+1);
wr_lock(&(klninfo->stat_lock));
klninfo->errorcount += ks->errorcount;
klninfo->noisecount += ks->noise;
wr_unlock(&(klninfo->stat_lock));
break;
default:
break;
}
} }
} }
return NULL; return NULL;
@ -375,7 +394,7 @@ static void klondike_flush_work(struct cgpu_info *klncgpu)
{ {
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
int dev; int dev;
applog(LOG_DEBUG, "Klondike flushing work"); applog(LOG_DEBUG, "Klondike flushing work");
for (dev = 0; dev <= klninfo->status->slavecount; dev++) { for (dev = 0; dev <= klninfo->status->slavecount; dev++) {
char *reply = SendCmdGetReply(klncgpu, 'A', dev, 0, NULL); char *reply = SendCmdGetReply(klncgpu, 'A', dev, 0, NULL);
@ -391,16 +410,16 @@ static bool klondike_thread_prepare(struct thr_info *thr)
{ {
struct cgpu_info *klncgpu = thr->cgpu; struct cgpu_info *klncgpu = thr->cgpu;
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
if (thr_info_create(&(klninfo->replies_thr), NULL, klondike_get_replies, (void *)klncgpu)) { if (thr_info_create(&(klninfo->replies_thr), NULL, klondike_get_replies, (void *)klncgpu)) {
applog(LOG_ERR, "%s%i: thread create failed", klncgpu->drv->name, klncgpu->device_id); applog(LOG_ERR, "%s%i: thread create failed", klncgpu->drv->name, klncgpu->device_id);
return false; return false;
} }
pthread_detach(klninfo->replies_thr.pth); pthread_detach(klninfo->replies_thr.pth);
// let the listening get started // let the listening get started
cgsleep_ms(100); cgsleep_ms(100);
return klondike_init(klncgpu); return klondike_init(klncgpu);
} }
@ -412,7 +431,7 @@ static bool klondike_thread_init(struct thr_info *thr)
return false; return false;
klondike_flush_work(klncgpu); klondike_flush_work(klncgpu);
return true; return true;
} }
@ -421,7 +440,7 @@ static void klondike_shutdown(struct thr_info *thr)
struct cgpu_info *klncgpu = thr->cgpu; struct cgpu_info *klncgpu = thr->cgpu;
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
int dev; int dev;
applog(LOG_DEBUG, "Klondike shutting down work"); applog(LOG_DEBUG, "Klondike shutting down work");
for (dev = 0; dev <= klninfo->status->slavecount; dev++) { for (dev = 0; dev <= klninfo->status->slavecount; dev++) {
SendCmdGetReply(klncgpu, 'E', dev, 1, "0"); SendCmdGetReply(klncgpu, 'E', dev, 1, "0");
@ -435,7 +454,7 @@ static void klondike_thread_enable(struct thr_info *thr)
if (klncgpu->usbinfo.nodev) if (klncgpu->usbinfo.nodev)
return; return;
//SendCmdGetReply(klncgpu, 'E', 0, 1, "0"); //SendCmdGetReply(klncgpu, 'E', 0, 1, "0");
} }
@ -445,29 +464,29 @@ static bool klondike_send_work(struct cgpu_info *klncgpu, int dev, struct work *
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
struct work *tmp; struct work *tmp;
WORKTASK data; WORKTASK data;
if (klncgpu->usbinfo.nodev) if (klncgpu->usbinfo.nodev)
return false; return false;
memcpy(data.midstate, work->midstate, MIDSTATE_BYTES); memcpy(data.midstate, work->midstate, MIDSTATE_BYTES);
memcpy(data.merkle, work->data + MERKLE_OFFSET, MERKLE_BYTES); memcpy(data.merkle, work->data + MERKLE_OFFSET, MERKLE_BYTES);
data.workid = (uint8_t)(klninfo->devinfo[dev].nextworkid++ & 0xFF); data.workid = (uint8_t)(klninfo->devinfo[dev].nextworkid++ & 0xFF);
work->subid = dev*256 + data.workid; work->subid = dev*256 + data.workid;
if (opt_log_level <= LOG_DEBUG) { if (opt_log_level <= LOG_DEBUG) {
char *hexdata = bin2hex(&data.workid, sizeof(data)-3); char *hexdata = bin2hex(&data.workid, sizeof(data)-3);
applog(LOG_DEBUG, "WORKDATA: %s", hexdata); applog(LOG_DEBUG, "WORKDATA: %s", hexdata);
free(hexdata); free(hexdata);
} }
applog(LOG_DEBUG, "Klondike sending work (%d:%02x)", dev, data.workid); applog(LOG_DEBUG, "Klondike sending work (%d:%02x)", dev, data.workid);
char *reply = SendCmdGetReply(klncgpu, 'W', dev, sizeof(data)-3, &data.workid); char *reply = SendCmdGetReply(klncgpu, 'W', dev, sizeof(data)-3, &data.workid);
if (reply != NULL) { if (reply != NULL) {
wr_lock(&(klninfo->stat_lock)); wr_lock(&(klninfo->stat_lock));
klninfo->status[dev] = *(WORKSTATUS *)(reply+2); klninfo->status[dev] = *(WORKSTATUS *)(reply+2);
wr_unlock(&(klninfo->stat_lock)); wr_unlock(&(klninfo->stat_lock));
// remove old work // remove old work
HASH_ITER(hh, klncgpu->queued_work, work, tmp) { HASH_ITER(hh, klncgpu->queued_work, work, tmp) {
if (work->queued && (work->subid == (int)(dev*256 + ((klninfo->devinfo[dev].nextworkid-2*MAX_WORK_COUNT) & 0xFF)))) if (work->queued && (work->subid == (int)(dev*256 + ((klninfo->devinfo[dev].nextworkid-2*MAX_WORK_COUNT) & 0xFF))))
work_completed(klncgpu, work); work_completed(klncgpu, work);
@ -482,7 +501,7 @@ static bool klondike_queue_full(struct cgpu_info *klncgpu)
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
struct work *work = NULL; struct work *work = NULL;
int dev, queued; int dev, queued;
for (queued = 0; queued < MAX_WORK_COUNT-1; queued++) for (queued = 0; queued < MAX_WORK_COUNT-1; queued++)
for (dev = 0; dev <= klninfo->status->slavecount; dev++) for (dev = 0; dev <= klninfo->status->slavecount; dev++)
if (klninfo->status[dev].workqc <= queued) { if (klninfo->status[dev].workqc <= queued) {
@ -495,7 +514,7 @@ static bool klondike_queue_full(struct cgpu_info *klncgpu)
break; break;
} }
} }
return true; return true;
} }
@ -505,10 +524,10 @@ static int64_t klondike_scanwork(struct thr_info *thr)
struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data); struct klondike_info *klninfo = (struct klondike_info *)(klncgpu->device_data);
int64_t newhashcount = 0; int64_t newhashcount = 0;
int dev; int dev;
if (klncgpu->usbinfo.nodev) if (klncgpu->usbinfo.nodev)
return -1; return -1;
restart_wait(thr, 200); restart_wait(thr, 200);
if (klninfo->status != NULL) { if (klninfo->status != NULL) {
rd_lock(&(klninfo->stat_lock)); rd_lock(&(klninfo->stat_lock));
@ -519,7 +538,7 @@ static int64_t klondike_scanwork(struct thr_info *thr)
newhashdev += klninfo->status[dev].hashcount - klninfo->devinfo[dev].lasthashcount; newhashdev += klninfo->status[dev].hashcount - klninfo->devinfo[dev].lasthashcount;
klninfo->devinfo[dev].lasthashcount = klninfo->status[dev].hashcount; klninfo->devinfo[dev].lasthashcount = klninfo->status[dev].hashcount;
klninfo->hashcount += (newhashdev << 32) / klninfo->status[dev].maxcount; klninfo->hashcount += (newhashdev << 32) / klninfo->status[dev].maxcount;
// todo: check stats for critical conditions // todo: check stats for critical conditions
} }
newhashcount += 0xffffffffull * (uint64_t)klninfo->noncecount; newhashcount += 0xffffffffull * (uint64_t)klninfo->noncecount;
@ -536,12 +555,12 @@ static void get_klondike_statline_before(char *buf, size_t siz, struct cgpu_info
uint8_t temp = 0xFF; uint8_t temp = 0xFF;
uint16_t fan = 0; uint16_t fan = 0;
int dev; int dev;
if (klninfo->status == NULL) if (klninfo->status == NULL)
return; return;
rd_lock(&(klninfo->stat_lock)); rd_lock(&(klninfo->stat_lock));
for (dev = 0; dev <= klninfo->status->slavecount; dev++) { for (dev = 0; dev <= klninfo->status->slavecount; dev++) {
if (klninfo->status[dev].temp < temp) if (klninfo->status[dev].temp < temp)
temp = klninfo->status[dev].temp; temp = klninfo->status[dev].temp;
fan += klninfo->cfg[dev].fantarget; fan += klninfo->cfg[dev].fantarget;
@ -558,21 +577,21 @@ static struct api_data *klondike_api_stats(struct cgpu_info *klncgpu)
struct api_data *root = NULL; struct api_data *root = NULL;
char buf[32]; char buf[32];
int dev; int dev;
if (klninfo->status == NULL) if (klninfo->status == NULL)
return NULL; return NULL;
rd_lock(&(klninfo->stat_lock)); rd_lock(&(klninfo->stat_lock));
for (dev = 0; dev <= klninfo->status->slavecount; dev++) { for (dev = 0; dev <= klninfo->status->slavecount; dev++) {
float fTemp = cvtKlnToC(klninfo->status[dev].temp); float fTemp = cvtKlnToC(klninfo->status[dev].temp);
sprintf(buf, "Temp %d", dev); sprintf(buf, "Temp %d", dev);
root = api_add_temp(root, buf, &fTemp, true); root = api_add_temp(root, buf, &fTemp, true);
double dClk = (double)klninfo->cfg[dev].hashclock; double dClk = (double)klninfo->cfg[dev].hashclock;
sprintf(buf, "Clock %d", dev); sprintf(buf, "Clock %d", dev);
root = api_add_freq(root, buf, &dClk, true); root = api_add_freq(root, buf, &dClk, true);
unsigned int iFan = (unsigned int)100 * klninfo->cfg[dev].fantarget / 255; unsigned int iFan = (unsigned int)100 * klninfo->cfg[dev].fantarget / 255;
sprintf(buf, "Fan Percent %d", dev); sprintf(buf, "Fan Percent %d", dev);
root = api_add_int(root, buf, (int *)(&iFan), true); root = api_add_int(root, buf, (int *)(&iFan), true);
@ -582,7 +601,7 @@ static struct api_data *klondike_api_stats(struct cgpu_info *klncgpu)
iFan = (unsigned int)TACH_FACTOR / klninfo->status[dev].fanspeed; iFan = (unsigned int)TACH_FACTOR / klninfo->status[dev].fanspeed;
sprintf(buf, "Fan RPM %d", dev); sprintf(buf, "Fan RPM %d", dev);
root = api_add_int(root, buf, (int *)(&iFan), true); root = api_add_int(root, buf, (int *)(&iFan), true);
if (klninfo->devinfo[dev].chipstats != NULL) { if (klninfo->devinfo[dev].chipstats != NULL) {
char data[2048]; char data[2048];
char one[32]; char one[32];
@ -595,7 +614,7 @@ static struct api_data *klondike_api_stats(struct cgpu_info *klncgpu)
strcat(data, one); strcat(data, one);
} }
root = api_add_string(root, buf, data, true); root = api_add_string(root, buf, data, true);
sprintf(buf, "Errors / Chip %d", dev); sprintf(buf, "Errors / Chip %d", dev);
data[0] = '\0'; data[0] = '\0';
for (n = 0; n < klninfo->status[dev].chipcount; n++) { for (n = 0; n < klninfo->status[dev].chipcount; n++) {
@ -607,9 +626,11 @@ static struct api_data *klondike_api_stats(struct cgpu_info *klncgpu)
} }
root = api_add_uint64(root, "Hash Count", &(klninfo->hashcount), true); root = api_add_uint64(root, "Hash Count", &(klninfo->hashcount), true);
root = api_add_uint64(root, "Error Count", &(klninfo->errorcount), true);
root = api_add_uint64(root, "Noise Count", &(klninfo->noisecount), true);
rd_unlock(&(klninfo->stat_lock)); rd_unlock(&(klninfo->stat_lock));
return root; return root;
} }

Loading…
Cancel
Save