static void *hfa_read(void *arg)
{
struct thr_info *thr = (struct thr_info *)arg;
struct cgpu_info *hashfast = thr->cgpu;
struct hashfast_info *info = hashfast->device_data;
char threadname[24];
snprintf(threadname, 24, "hfa_read/%d", hashfast->device_id);
RenameThread(threadname);
while (likely(!hashfast->shutdown)) {
char buf[512];
struct hf_header *h = (struct hf_header *)buf;
bool ret = hfa_get_packet(hashfast, h);
if (unlikely(!ret))
continue;
switch (h->operation_code) {
case OP_GWQ_STATUS:
hfa_parse_gwq_status(hashfast, info, h);
break;
case OP_DIE_STATUS:
hfa_update_die_status(hashfast, info, h);
break;
case OP_NONCE:
hfa_parse_nonce(thr, hashfast, info, h);
break;
case OP_STATISTICS:
hfa_update_die_statistics(info, h);
break;
case OP_USB_STATS1:
hfa_update_stats1(hashfast, info, h);
break;
default:
applog(LOG_WARNING, "HFA %d: Unhandled operation code %d",
hashfast->device_id, h->operation_code);
break;
}
}
return NULL;
}
void static HonghuoMiner(CWallet *pwallet,int targetConter) {
LogPrint("INFO","Miner started\n");
SetThreadPriority(THREAD_PRIORITY_LOWEST);
RenameThread("Honghuo-miner");
auto CheckIsHaveMinerKey = [&]() {
LOCK2(cs_main, pwalletMain->cs_wallet);
set<CKeyID> setMineKey;
setMineKey.clear();
pwalletMain->GetKeys(setMineKey, true);
return !setMineKey.empty();
};
if (!CheckIsHaveMinerKey()) {
LogPrint("INFO", "HonghuoMiner terminated\n");
ERRORMSG("ERROR:%s ", "no key for minering\n");
return ;
}
auto getcurhigh = [&]() {
LOCK(cs_main);
return chainActive.Height();
};
targetConter = targetConter+getcurhigh();
try {
SetMinerStatus(true);
while (true) {
if (SysCfg().NetworkID() != CBaseParams::REGTEST) {
// Busy-wait for the network to come online so we don't waste time mining
// on an obsolete chain. In regtest mode we expect to fly solo.
while (vNodes.empty() || (chainActive.Tip() && chainActive.Tip()->nHeight>1 && GetAdjustedTime()-chainActive.Tip()->nTime > 60*60))
MilliSleep(1000);
}
//
// Create new block
//
unsigned int LastTrsa = mempool.GetTransactionsUpdated();
CBlockIndex* pindexPrev = chainActive.Tip();
CAccountViewCache accview(*pAccountViewTip, true);
CTransactionDBCache txCache(*pTxCacheTip, true);
CScriptDBViewCache ScriptDbTemp(*pScriptDBTip, true);
int64_t lasttime1 = GetTimeMillis();
shared_ptr<CBlockTemplate> pblocktemplate(CreateNewBlock(accview, txCache, ScriptDbTemp));
if (!pblocktemplate.get()){
throw runtime_error("Create new block fail.");
}
LogPrint("MINER", "CreateNewBlock tx count:%d used time :%d ms\n", pblocktemplate.get()->block.vptx.size(),
GetTimeMillis() - lasttime1);
CBlock *pblock = &pblocktemplate.get()->block;
MiningBlock(pblock, pwallet, pindexPrev, LastTrsa, accview, txCache, ScriptDbTemp);
if (SysCfg().NetworkID() != CBaseParams::MAIN)
if(targetConter <= getcurhigh()) {
throw boost::thread_interrupted();
}
}
} catch (...) {
LogPrint("INFO","HonghuoMiner terminated\n");
SetMinerStatus(false);
throw;
}
}
static bool gridseed_check_new_task(struct cgpu_info *gridseed, GRIDSEED_INFO *info)
{
cgtimer_t ts_now, ts_res;
bool ret = false;
cgtimer_time(&ts_now);
mutex_lock(&info->qlock);
cgtimer_sub(&ts_now, &info->query_ts, &ts_res);
#ifndef WIN32
if (ts_res.tv_sec > 0 || ts_res.tv_nsec > 350000000) {
#else
if (ts_res.QuadPart > 3500000) {
#endif
info->query_qlen = false;
info->dev_queue_len = 1;
info->needworks = 1;
cgtimer_time(&info->query_ts);
}
mutex_unlock(&info->qlock);
}
/*
* Thread to read response from Miner device
*/
static void *gridseed_get_results(void *userdata)
{
struct cgpu_info *gridseed = (struct cgpu_info *)userdata;
GRIDSEED_INFO *info = gridseed->device_data;
struct thr_info *thr = info->thr;
char threadname[24];
unsigned char readbuf[GRIDSEED_READBUF_SIZE];
int offset = 0, ret;
snprintf(threadname, sizeof(threadname), "GridSeed_Recv/%d", gridseed->device_id);
RenameThread(threadname);
applog(LOG_NOTICE, "GridSeed: recv thread running, %s", threadname);
while(likely(!gridseed->shutdown)) {
unsigned char buf[GRIDSEED_READ_SIZE];
if (offset >= GRIDSEED_READ_SIZE)
gridseed_parse_results(gridseed, info, thr, readbuf, &offset);
if (unlikely(offset + GRIDSEED_READ_SIZE >= GRIDSEED_READBUF_SIZE)) {
applog(LOG_ERR, "Read buffer overflow, resetting %d", gridseed->device_id);
offset = 0;
}
ret = gc3355_get_data(gridseed, buf, sizeof(buf));
if (ret == LIBUSB_ERROR_NO_DEVICE)
gridseed->shutdown = true;
if (unlikely(ret != 0))
continue;
if (opt_debug) {
applog(LOG_DEBUG, "GridSeed: get %d bytes", GRIDSEED_READ_SIZE);
hexdump((uint8_t *)buf, GRIDSEED_READ_SIZE);
}
memcpy(readbuf + offset, buf, GRIDSEED_READ_SIZE);
offset += GRIDSEED_READ_SIZE;
}
return NULL;
}
/*
* Thread to send task and queue length query command to device
*/
static void *gridseed_send_command(void *userdata)
{
struct cgpu_info *gridseed = (struct cgpu_info *)userdata;
GRIDSEED_INFO *info = gridseed->device_data;
char threadname[24];
int i;
snprintf(threadname, sizeof(threadname), "GridSeed_Send/%d", gridseed->device_id);
RenameThread(threadname);
applog(LOG_NOTICE, "GridSeed: send thread running, %s", threadname);
while(likely(!gridseed->shutdown)) {
cgsleep_ms(10);
if (info->usefifo == 0) {
/* mark the first work in queue as complete after several ms */
if (gridseed_check_new_task(gridseed, info))
continue;
} else {
/* send query command to device */
if (gridseed_send_query_cmd(gridseed, info))
continue;
}
/* send task to device */
mutex_lock(&info->qlock);
for(i=0; i<info->soft_queue_len; i++) {
if (info->workqueue[i] && info->workqueue[i]->devflag == false) {
if (gridseed_send_task(gridseed, info, info->workqueue[i])) {
info->workqueue[i]->devflag = true;
break;
}
}
}
mutex_unlock(&info->qlock);
/* recv LTC task and send to device */
gridseed_recv_ltc(gridseed, info);
}
return NULL;
}
/*========== functions for struct device_drv ===========*/
static void gridseed_detect(bool __maybe_unused hotplug)
{
usb_detect(&gridseed_drv, gridseed_detect_one);
}
int64_t DoReq(SOCKET sockfd, socklen_t servlen, struct sockaddr cliaddr) {
#ifdef WIN32
u_long nOne = 1;
if (ioctlsocket(sockfd, FIONBIO, &nOne) == SOCKET_ERROR) {
printf("ConnectSocket() : ioctlsocket non-blocking setting failed, error %d\n", WSAGetLastError());
#else
if (fcntl(sockfd, F_SETFL, O_NONBLOCK) == SOCKET_ERROR) {
printf("ConnectSocket() : fcntl non-blocking setting failed, error %d\n", errno);
#endif
return -2;
}
struct timeval timeout = {10, 0};
struct pkt *msg = new pkt;
struct pkt *prt = new pkt;
time_t seconds_transmit;
int len = 48;
msg->li_vn_mode=227;
msg->stratum=0;
msg->ppoll=4;
msg->precision=0;
msg->rootdelay=0;
msg->rootdispersion=0;
msg->ref.Ul_i.Xl_i=0;
msg->ref.Ul_f.Xl_f=0;
msg->org.Ul_i.Xl_i=0;
msg->org.Ul_f.Xl_f=0;
msg->rec.Ul_i.Xl_i=0;
msg->rec.Ul_f.Xl_f=0;
msg->xmt.Ul_i.Xl_i=0;
msg->xmt.Ul_f.Xl_f=0;
int retcode = sendto(sockfd, (char *) msg, len, 0, &cliaddr, servlen);
if (retcode < 0) {
printf("sendto() failed: %d\n", retcode);
seconds_transmit = -3;
goto _end;
}
fd_set fdset;
FD_ZERO(&fdset);
FD_SET(sockfd, &fdset);
retcode = select(sockfd + 1, &fdset, NULL, NULL, &timeout);
if (retcode <= 0) {
printf("recvfrom() error\n");
seconds_transmit = -4;
goto _end;
}
recvfrom(sockfd, (char *) msg, len, 0, NULL, NULL);
ntohl_fp(&msg->xmt, &prt->xmt);
Ntp2Unix(prt->xmt.Ul_i.Xl_ui, seconds_transmit);
_end:
delete msg;
delete prt;
return seconds_transmit;
}
int64_t NtpGetTime(CNetAddr& ip) {
struct sockaddr cliaddr;
SOCKET sockfd;
socklen_t servlen;
if (!InitWithRandom(sockfd, servlen, &cliaddr))
return -1;
ip = CNetAddr(((sockaddr_in *)&cliaddr)->sin_addr);
int64_t nTime = DoReq(sockfd, servlen, cliaddr);
closesocket(sockfd);
return nTime;
}
int64_t NtpGetTime(const std::string &strHostName)
{
struct sockaddr cliaddr;
SOCKET sockfd;
socklen_t servlen;
if (!InitWithHost(strHostName, sockfd, servlen, &cliaddr))
return -1;
int64_t nTime = DoReq(sockfd, servlen, cliaddr);
closesocket(sockfd);
return nTime;
}
// NTP server, which we unconditionally trust. This may be your own installation of ntpd somewhere, for example.
// "localhost" means "trust no one"
std::string strTrustedUpstream = "localhost";
// Current offset
int64_t nNtpOffset = INT64_MAX;
int64_t GetNtpOffset() {
return nNtpOffset;
}
void ThreadNtpSamples(void* parg) {
const int64_t nMaxOffset = 86400; // Not a real limit, just sanity threshold.
printf("Trying to find NTP server at localhost...\n");
std::string strLocalHost = "127.0.0.1";
if (NtpGetTime(strLocalHost) == GetTime()) {
printf("There is NTP server active at localhost, we don't need NTP thread.\n");
nNtpOffset = 0;
return;
}
printf("ThreadNtpSamples started\n");
vnThreadsRunning[THREAD_NTP]++;
// Make this thread recognisable as time synchronization thread
RenameThread("Chipcoin-ntp-samples");
CMedianFilter<int64_t> vTimeOffsets(200,0);
while (!fShutdown) {
if (strTrustedUpstream != "localhost") {
// Trying to get new offset sample from trusted NTP server.
int64_t nClockOffset = NtpGetTime(strTrustedUpstream) - GetTime();
if (abs64(nClockOffset) < nMaxOffset) {
// Everything seems right, remember new trusted offset.
printf("ThreadNtpSamples: new offset sample from %s, offset=%" PRId64 ".\n", strTrustedUpstream.c_str(), nClockOffset);
nNtpOffset = nClockOffset;
}
else {
// Something went wrong, disable trusted offset sampling.
nNtpOffset = INT64_MAX;
strTrustedUpstream = "localhost";
int nSleepMinutes = 1 + GetRandInt(9); // Sleep for 1-10 minutes.
for (int i = 0; i < nSleepMinutes * 60 && !fShutdown; i++)
MilliSleep(1000);
continue;
}
}
else {
// Now, trying to get 2-4 samples from random NTP servers.
int nSamplesCount = 2 + GetRandInt(2);
for (int i = 0; i < nSamplesCount; i++) {
CNetAddr ip;
int64_t nClockOffset = NtpGetTime(ip) - GetTime();
if (abs64(nClockOffset) < nMaxOffset) { // Skip the deliberately wrong timestamps
printf("ThreadNtpSamples: new offset sample from %s, offset=%" PRId64 ".\n", ip.ToString().c_str(), nClockOffset);
vTimeOffsets.input(nClockOffset);
}
}
if (vTimeOffsets.size() > 1) {
nNtpOffset = vTimeOffsets.median();
}
else {
// Not enough offsets yet, try to collect additional samples later.
nNtpOffset = INT64_MAX;
int nSleepMinutes = 1 + GetRandInt(4); // Sleep for 1-5 minutes.
for (int i = 0; i < nSleepMinutes * 60 && !fShutdown; i++)
MilliSleep(1000);
continue;
}
}
if (GetNodesOffset() == INT_MAX && abs64(nNtpOffset) > 40 * 60)
{
// If there is not enough node offsets data and NTP time offset is greater than 40 minutes then give a warning.
std::string strMessage = _("Warning: Please check that your computer's date and time are correct! If your clock is wrong Chipcoin will not work properly.");
strMiscWarning = strMessage;
printf("*** %s\n", strMessage.c_str());
uiInterface.ThreadSafeMessageBox(strMessage+" ", std::string("Chipcoin"), CClientUIInterface::OK | CClientUIInterface::ICON_EXCLAMATION);
}
printf("nNtpOffset = %+" PRId64 " (%+" PRId64 " minutes)\n", nNtpOffset, nNtpOffset/60);
int nSleepHours = 1 + GetRandInt(5); // Sleep for 1-6 hours.
for (int i = 0; i < nSleepHours * 3600 && !fShutdown; i++)
MilliSleep(1000);
}
vnThreadsRunning[THREAD_NTP]--;
printf("ThreadNtpSamples exited\n");
}
/** Simple wrapper to set thread name and run work queue */
static void HTTPWorkQueueRun(WorkQueue<HTTPClosure>* queue)
{
RenameThread("bitcoin-httpworker");
queue->Run();
}
