static bool cpu_thread_init(struct thr_info *thr)
{
const int thr_id = thr->id;
struct cgpu_info *cgpu = thr->cgpu;
mutex_lock(&cpualgo_lock);
switch (opt_algo)
{
case ALGO_AUTO:
case ALGO_FASTAUTO:
opt_algo = pick_fastest_algo();
default:
break;
}
mutex_unlock(&cpualgo_lock);
cgpu->kname = algo_names[opt_algo];
if (opt_algo == ALGO_SCRYPT)
cgpu->min_nonce_diff = 1./0x10000;
/* Set worker threads to nice 19 and then preferentially to SCHED_IDLE
* and if that fails, then SCHED_BATCH. No need for this to be an
* error if it fails */
setpriority(PRIO_PROCESS, 0, 19);
drop_policy();
/* Cpu affinity only makes sense if the number of threads is a multiple
* of the number of CPUs */
if (!(opt_n_threads % num_processors))
affine_to_cpu(dev_from_id(thr_id), dev_from_id(thr_id) % num_processors);
return true;
}
static bool cpu_thread_init(struct thr_info *thr)
{
const int thr_id = thr->id;
/* Set worker threads to nice 19 and then preferentially to SCHED_IDLE
* and if that fails, then SCHED_BATCH. No need for this to be an
* error if it fails */
setpriority(PRIO_PROCESS, 0, 19);
drop_policy();
/* Cpu affinity only makes sense if the number of threads is a multiple
* of the number of CPUs */
if (!(opt_n_threads % num_processors))
affine_to_cpu(dev_from_id(thr_id), dev_from_id(thr_id) % num_processors);
return true;
}
static void *miner_thread(void *userdata)
{
struct thr_info *mythr = userdata;
int thr_id = mythr->id;
uint32_t max_nonce = 0xffffff;
/* Set worker threads to nice 19 and then preferentially to SCHED_IDLE
* and if that fails, then SCHED_BATCH. No need for this to be an
* error if it fails */
setpriority(PRIO_PROCESS, 0, 19);
drop_policy();
/* Cpu affinity only makes sense if the number of threads is a multiple
* of the number of CPUs */
if (!(opt_n_threads % num_processors))
affine_to_cpu(mythr->id, mythr->id % num_processors);
while (1) {
struct work work __attribute__((aligned(128)));
uint64_t hashes_done;
struct timeval tv_start, tv_end, diff;
uint64_t max64;
bool rc;
/* obtain new work from internal workio thread */
if (unlikely(!get_work(mythr, &work))) {
applog(LOG_ERR, "work retrieval failed, exiting "
"mining thread %d", mythr->id);
goto out;
}
hashes_done = 0;
gettimeofday(&tv_start, NULL);
rc = scanhash(thr_id, work.data, work.target, max_nonce, &hashes_done);
/* record scanhash elapsed time */
gettimeofday(&tv_end, NULL);
timeval_subtract(&diff, &tv_end, &tv_start);
hashmeter(thr_id, &diff, hashes_done);
/* adjust max_nonce to meet target scan time */
if (diff.tv_usec > 500000)
diff.tv_sec++;
if (diff.tv_sec > 0) {
max64 =
(hashes_done / 65536 * opt_scantime) / diff.tv_sec;
if (max64 > 0xfffffffaULL)
max64 = 0xfffffffaULL;
max_nonce = max64;
}
/* if nonce found, submit work */
if (rc && !submit_work(mythr, &work))
break;
}
out:
tq_freeze(mythr->q);
return NULL;
}