From 5e3142cf68e1b6039a3798972d5ed60e683612d3 Mon Sep 17 00:00:00 2001 From: Jan Berdajs Date: Sun, 8 Jun 2014 18:33:01 +0200 Subject: [PATCH] remove unused code (mostly intended for ASICs which are not supported in sgminer), fix some compiler warnings --- algorithm/scrypt.c | 2 - miner.h | 25 --- sgminer.c | 422 ++------------------------------------------- util.c | 4 +- 4 files changed, 13 insertions(+), 440 deletions(-) diff --git a/algorithm/scrypt.c b/algorithm/scrypt.c index ab34b64a..1b1b329f 100644 --- a/algorithm/scrypt.c +++ b/algorithm/scrypt.c @@ -418,5 +418,3 @@ void scrypt_regenhash(struct work *work) scrypt_n_1_1_256_sp(data, scratchbuf, ohash, work->pool->algorithm.n); flip32(ohash, ohash); } - -static const uint32_t diff1targ = 0x0000ffff; diff --git a/miner.h b/miner.h index 41fb4df8..800eb561 100644 --- a/miner.h +++ b/miner.h @@ -522,11 +522,6 @@ struct cgpu_info { struct sgminer_stats sgminer_stats; - pthread_rwlock_t qlock; - struct work *queued_work; - struct work *unqueued_work; - unsigned int queued_count; - bool shutdown; struct timeval dev_start_tv; @@ -1009,7 +1004,6 @@ extern pthread_cond_t restart_cond; extern void clear_stratum_shares(struct pool *pool); extern void clear_pool_work(struct pool *pool); extern void set_target(unsigned char *dest_target, double diff, double diff_multiplier2); -extern int restart_wait(struct thr_info *thr, unsigned int mstime); extern void kill_work(void); @@ -1061,7 +1055,6 @@ extern struct cgpu_info gpus[MAX_GPUDEVICES]; extern double total_secs; extern int mining_threads; extern int total_devices; -extern int zombie_devs; extern struct cgpu_info **devices; extern int total_pools; extern struct pool **pools; @@ -1368,26 +1361,9 @@ struct work { extern void get_datestamp(char *, size_t, struct timeval *); extern void inc_hw_errors(struct thr_info *thr); extern bool test_nonce(struct work *work, uint32_t nonce); -extern bool test_nonce_diff(struct work *work, uint32_t nonce, double diff); extern bool submit_tested_work(struct thr_info *thr, struct work *work); extern bool submit_nonce(struct thr_info *thr, struct work *work, uint32_t nonce); -extern bool submit_noffset_nonce(struct thr_info *thr, struct work *work, uint32_t nonce, - int noffset); extern struct work *get_work(struct thr_info *thr, const int thr_id); -extern void __add_queued(struct cgpu_info *cgpu, struct work *work); -extern struct work *get_queued(struct cgpu_info *cgpu); -extern void add_queued(struct cgpu_info *cgpu, struct work *work); -extern struct work *get_queue_work(struct thr_info *thr, struct cgpu_info *cgpu, int thr_id); -extern struct work *__find_work_bymidstate(struct work *que, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen); -extern struct work *find_queued_work_bymidstate(struct cgpu_info *cgpu, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen); -extern struct work *clone_queued_work_bymidstate(struct cgpu_info *cgpu, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen); -extern void __work_completed(struct cgpu_info *cgpu, struct work *work); -extern int age_queued_work(struct cgpu_info *cgpu, double secs); -extern void work_completed(struct cgpu_info *cgpu, struct work *work); -extern struct work *take_queued_work_bymidstate(struct cgpu_info *cgpu, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen); -extern void flush_queue(struct cgpu_info *cgpu); -extern void hash_driver_work(struct thr_info *mythr); -extern void hash_queued_work(struct thr_info *mythr); extern void _wlog(const char *str); extern void _wlogprint(const char *str); extern int curses_int(const char *query); @@ -1416,7 +1392,6 @@ extern void adl(void); extern void app_restart(void); extern void clean_work(struct work *work); extern void free_work(struct work *work); -extern void set_work_ntime(struct work *work, int ntime); extern struct work *copy_work_noffset(struct work *base_work, int noffset); #define copy_work(work_in) copy_work_noffset(work_in, 0) extern struct thr_info *get_thread(int thr_id); diff --git a/sgminer.c b/sgminer.c index 9ef1db68..63737961 100644 --- a/sgminer.c +++ b/sgminer.c @@ -100,7 +100,6 @@ int opt_expiry = 28; algorithm_t *opt_algorithm; -static const bool opt_time = true; unsigned long long global_hashrate; unsigned long global_quota_gcd = 1; bool opt_show_coindiff = false; @@ -117,7 +116,6 @@ static int opt_devs_enabled; static bool opt_display_devs; static bool opt_removedisabled; int total_devices; -int zombie_devs; static int most_devices; struct cgpu_info **devices; int mining_threads; @@ -816,6 +814,7 @@ static char *set_pool_thread_concurrency(const char *arg) return NULL; } +#ifdef HAVE_ADL static char *set_pool_gpu_engine(const char *arg) { struct pool *pool = get_current_pool(); @@ -843,6 +842,7 @@ static char *set_pool_gpu_fan(const char *arg) pool->gpu_fan = arg; return NULL; } +#endif static char *set_pool_nfactor(const char *arg) { @@ -3736,17 +3736,6 @@ static void _copy_work(struct work *work, const struct work *base_work, int noff work->coinbase = strdup(base_work->coinbase); } -void set_work_ntime(struct work *work, int ntime) -{ - uint32_t *work_ntime = (uint32_t *)(work->data + 68); - - *work_ntime = htobe32(ntime); - if (work->ntime) { - free(work->ntime); - work->ntime = bin2hex((unsigned char *)work_ntime, 4); - } -} - /* Generates a copy of an existing work struct, creating fresh heap allocations * for all dynamically allocated arrays within the struct. noffset is used for * when a driver has internally rolled the ntime, noffset is a relative value. @@ -4035,34 +4024,6 @@ static void discard_stale(void) applog(LOG_DEBUG, "Discarded %d stales that didn't match current hash", stale); } -/* A generic wait function for threads that poll that will wait a specified - * time tdiff waiting on the pthread conditional that is broadcast when a - * work restart is required. Returns the value of pthread_cond_timedwait - * which is zero if the condition was met or ETIMEDOUT if not. - */ -int restart_wait(struct thr_info *thr, unsigned int mstime) -{ - struct timeval now, then, tdiff; - struct timespec abstime; - int rc; - - tdiff.tv_sec = mstime / 1000; - tdiff.tv_usec = mstime * 1000 - (tdiff.tv_sec * 1000000); - cgtime(&now); - timeradd(&now, &tdiff, &then); - abstime.tv_sec = then.tv_sec; - abstime.tv_nsec = then.tv_usec * 1000; - - mutex_lock(&restart_lock); - if (thr->work_restart) - rc = 0; - else - rc = pthread_cond_timedwait(&restart_cond, &restart_lock, &abstime); - mutex_unlock(&restart_lock); - - return rc; -} - static void *restart_thread(void __maybe_unused *arg) { struct pool *cp = current_pool(); @@ -4089,7 +4050,6 @@ static void *restart_thread(void __maybe_unused *arg) if (cgpu->deven != DEV_ENABLED) continue; mining_thr[i]->work_restart = true; - flush_queue(cgpu); cgpu->drv->flush_work(cgpu); } @@ -4157,17 +4117,6 @@ static bool block_exists(char *hexstr) return false; } -/* Tests if this work is from a block that has been seen before */ -static inline bool from_existing_block(struct work *work) -{ - char *hexstr = bin2hex(work->data + 8, 18); - bool ret; - - ret = block_exists(hexstr); - free(hexstr); - return ret; -} - static int block_sort(struct block *blocka, struct block *blockb) { return blocka->block_no - blockb->block_no; @@ -4475,7 +4424,10 @@ void write_config(FILE *fcfg) if (nDevs) { fputs(",\n\"intensity\" : \"", fcfg); for(i = 0; i < nDevs; i++) - fprintf(fcfg, gpus[i].dynamic ? "%sd" : "%s%d", i > 0 ? "," : "", gpus[i].intensity); + if (gpus[i].dynamic) + fprintf(fcfg, "%sd", i > 0 ? "," : ""); + else + fprintf(fcfg, "%s%d", i > 0 ? "," : "", gpus[i].intensity); fputs("\",\n\"xintensity\" : \"", fcfg); for(i = 0; i < nDevs; i++) @@ -6288,7 +6240,7 @@ static void get_work_prepare_thread(struct thr_info *mythr, struct work *work) n_threads = mining_threads; #endif - if (unlikely(pthread_create(&restart_thr, NULL, restart_mining_threads_thread, (void *)n_threads))) + if (unlikely(pthread_create(&restart_thr, NULL, restart_mining_threads_thread, (void *) (intptr_t) n_threads))) quit(1, "restart_mining_threads create thread failed"); sleep(60); quit(1, "thread was not cancelled in 60 seconds after restart_mining_threads"); @@ -6422,18 +6374,6 @@ bool test_nonce(struct work *work, uint32_t nonce) return (le32toh(*hash_32) <= diff1targ); } -/* For testing a nonce against an arbitrary diff */ -bool test_nonce_diff(struct work *work, uint32_t nonce, double diff) -{ - uint64_t *hash64 = (uint64_t *)(work->hash + 24), diff64; - - rebuild_nonce(work, nonce); - diff64 = work->pool->algorithm.diff_nonce; - diff64 /= diff; - - return (le64toh(*hash64) <= diff64); -} - static void update_work_stats(struct thr_info *thr, struct work *work) { double test_diff = current_diff; @@ -6489,36 +6429,6 @@ bool submit_nonce(struct thr_info *thr, struct work *work, uint32_t nonce) return true; } -/* Allows drivers to submit work items where the driver has changed the ntime - * value by noffset. Must be only used with a work protocol that does not ntime - * roll itself intrinsically to generate work (eg stratum). We do not touch - * the original work struct, but the copy of it only. */ -bool submit_noffset_nonce(struct thr_info *thr, struct work *work_in, uint32_t nonce, - int noffset) -{ - struct work *work = make_work(); - bool ret = false; - - _copy_work(work, work_in, noffset); - if (!test_nonce(work, nonce)) { - inc_hw_errors(thr); - goto out; - } - ret = true; - update_work_stats(thr, work); - if (!fulltest(work->hash, work->target)) { - applog(LOG_INFO, "%s %d: Share above target", thr->cgpu->drv->name, - thr->cgpu->device_id); - goto out; - } - submit_work_async(work); - -out: - if (!ret) - free_work(work); - return ret; -} - static inline bool abandon_work(struct work *work, struct timeval *wdiff, uint64_t hashes) { if (wdiff->tv_sec > opt_scantime || @@ -6708,315 +6618,6 @@ static void hash_sole_work(struct thr_info *mythr) cgpu->deven = DEV_DISABLED; } -/* Put a new unqueued work item in cgpu->unqueued_work under cgpu->qlock till - * the driver tells us it's full so that it may extract the work item using - * the get_queued() function which adds it to the hashtable on - * cgpu->queued_work. */ -static void fill_queue(struct thr_info *mythr, struct cgpu_info *cgpu, struct device_drv *drv, const int thr_id) -{ - do { - bool need_work; - - /* Do this lockless just to know if we need more unqueued work. */ - need_work = (!cgpu->unqueued_work); - - /* get_work is a blocking function so do it outside of lock - * to prevent deadlocks with other locks. */ - if (need_work) { - struct work *work = get_work(mythr, thr_id); - - wr_lock(&cgpu->qlock); - /* Check we haven't grabbed work somehow between - * checking and picking up the lock. */ - if (likely(!cgpu->unqueued_work)) - cgpu->unqueued_work = work; - else - need_work = false; - wr_unlock(&cgpu->qlock); - - if (unlikely(!need_work)) - discard_work(work); - } - /* The queue_full function should be used by the driver to - * actually place work items on the physical device if it - * does have a queue. */ - } while (!drv->queue_full(cgpu)); -} - -/* Add a work item to a cgpu's queued hashlist */ -void __add_queued(struct cgpu_info *cgpu, struct work *work) -{ - cgpu->queued_count++; - HASH_ADD_INT(cgpu->queued_work, id, work); -} - -/* This function is for retrieving one work item from the unqueued pointer and - * adding it to the hashtable of queued work. Code using this function must be - * able to handle NULL as a return which implies there is no work available. */ -struct work *get_queued(struct cgpu_info *cgpu) -{ - struct work *work = NULL; - - wr_lock(&cgpu->qlock); - if (cgpu->unqueued_work) { - work = cgpu->unqueued_work; - if (unlikely(stale_work(work, false))) { - discard_work(work); - work = NULL; - wake_gws(); - } else - __add_queued(cgpu, work); - cgpu->unqueued_work = NULL; - } - wr_unlock(&cgpu->qlock); - - return work; -} - -void add_queued(struct cgpu_info *cgpu, struct work *work) -{ - wr_lock(&cgpu->qlock); - __add_queued(cgpu, work); - wr_unlock(&cgpu->qlock); -} - -/* Get fresh work and add it to cgpu's queued hashlist */ -struct work *get_queue_work(struct thr_info *thr, struct cgpu_info *cgpu, int thr_id) -{ - struct work *work = get_work(thr, thr_id); - - add_queued(cgpu, work); - return work; -} - -/* This function is for finding an already queued work item in the - * given que hashtable. Code using this function must be able - * to handle NULL as a return which implies there is no matching work. - * The calling function must lock access to the que if it is required. - * The common values for midstatelen, offset, datalen are 32, 64, 12 */ -struct work *__find_work_bymidstate(struct work *que, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen) -{ - struct work *work, *tmp, *ret = NULL; - - HASH_ITER(hh, que, work, tmp) { - if (memcmp(work->midstate, midstate, midstatelen) == 0 && - memcmp(work->data + offset, data, datalen) == 0) { - ret = work; - break; - } - } - - return ret; -} - -/* This function is for finding an already queued work item in the - * device's queued_work hashtable. Code using this function must be able - * to handle NULL as a return which implies there is no matching work. - * The common values for midstatelen, offset, datalen are 32, 64, 12 */ -struct work *find_queued_work_bymidstate(struct cgpu_info *cgpu, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen) -{ - struct work *ret; - - rd_lock(&cgpu->qlock); - ret = __find_work_bymidstate(cgpu->queued_work, midstate, midstatelen, data, offset, datalen); - rd_unlock(&cgpu->qlock); - - return ret; -} - -struct work *clone_queued_work_bymidstate(struct cgpu_info *cgpu, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen) -{ - struct work *work, *ret = NULL; - - rd_lock(&cgpu->qlock); - work = __find_work_bymidstate(cgpu->queued_work, midstate, midstatelen, data, offset, datalen); - if (work) - ret = copy_work(work); - rd_unlock(&cgpu->qlock); - - return ret; -} - -void __work_completed(struct cgpu_info *cgpu, struct work *work) -{ - cgpu->queued_count--; - HASH_DEL(cgpu->queued_work, work); -} - -/* This iterates over a queued hashlist finding work started more than secs - * seconds ago and discards the work as completed. The driver must set the - * work->tv_work_start value appropriately. Returns the number of items aged. */ -int age_queued_work(struct cgpu_info *cgpu, double secs) -{ - struct work *work, *tmp; - struct timeval tv_now; - int aged = 0; - - cgtime(&tv_now); - - wr_lock(&cgpu->qlock); - HASH_ITER(hh, cgpu->queued_work, work, tmp) { - if (tdiff(&tv_now, &work->tv_work_start) > secs) { - __work_completed(cgpu, work); - aged++; - } - } - wr_unlock(&cgpu->qlock); - - return aged; -} - -/* This function should be used by queued device drivers when they're sure - * the work struct is no longer in use. */ -void work_completed(struct cgpu_info *cgpu, struct work *work) -{ - wr_lock(&cgpu->qlock); - __work_completed(cgpu, work); - wr_unlock(&cgpu->qlock); - - free_work(work); -} - -/* Combines find_queued_work_bymidstate and work_completed in one function - * withOUT destroying the work so the driver must free it. */ -struct work *take_queued_work_bymidstate(struct cgpu_info *cgpu, char *midstate, size_t midstatelen, char *data, int offset, size_t datalen) -{ - struct work *work; - - wr_lock(&cgpu->qlock); - work = __find_work_bymidstate(cgpu->queued_work, midstate, midstatelen, data, offset, datalen); - if (work) - __work_completed(cgpu, work); - wr_unlock(&cgpu->qlock); - - return work; -} - -void flush_queue(struct cgpu_info *cgpu) -{ - struct work *work = NULL; - - if (unlikely(!cgpu)) - return; - - /* Use only a trylock in case we get into a deadlock with a queueing - * function holding the read lock when we're called. */ - if (wr_trylock(&cgpu->qlock)) - return; - work = cgpu->unqueued_work; - cgpu->unqueued_work = NULL; - wr_unlock(&cgpu->qlock); - - if (work) { - free_work(work); - applog(LOG_DEBUG, "Discarded queued work item"); - } -} - -/* This version of hash work is for devices that are fast enough to always - * perform a full nonce range and need a queue to maintain the device busy. - * Work creation and destruction is not done from within this function - * directly. */ -void hash_queued_work(struct thr_info *mythr) -{ - struct timeval tv_start = {0, 0}, tv_end; - struct cgpu_info *cgpu = mythr->cgpu; - struct device_drv *drv = cgpu->drv; - const int thr_id = mythr->id; - int64_t hashes_done = 0; - - while (likely(!cgpu->shutdown)) { - struct timeval diff; - int64_t hashes; - - mythr->work_update = false; - - fill_queue(mythr, cgpu, drv, thr_id); - - hashes = drv->scanwork(mythr); - - /* Reset the bool here in case the driver looks for it - * synchronously in the scanwork loop. */ - mythr->work_restart = false; - - if (unlikely(hashes == -1 )) { - applog(LOG_ERR, "%s %d failure, disabling!", drv->name, cgpu->device_id); - cgpu->deven = DEV_DISABLED; - dev_error(cgpu, REASON_THREAD_ZERO_HASH); - break; - } - - hashes_done += hashes; - cgtime(&tv_end); - timersub(&tv_end, &tv_start, &diff); - /* Update the hashmeter at most 5 times per second */ - if ((hashes_done && (diff.tv_sec > 0 || diff.tv_usec > 200000)) || - diff.tv_sec >= opt_log_interval) { - hashmeter(thr_id, &diff, hashes_done); - hashes_done = 0; - copy_time(&tv_start, &tv_end); - } - - if (unlikely(mythr->pause || cgpu->deven != DEV_ENABLED)) - mt_disable(mythr, thr_id, drv); - - if (mythr->work_update) - drv->update_work(cgpu); - } - cgpu->deven = DEV_DISABLED; -} - -/* This version of hash_work is for devices drivers that want to do their own - * work management entirely, usually by using get_work(). Note that get_work - * is a blocking function and will wait indefinitely if no work is available - * so this must be taken into consideration in the driver. */ -void hash_driver_work(struct thr_info *mythr) -{ - struct timeval tv_start = {0, 0}, tv_end; - struct cgpu_info *cgpu = mythr->cgpu; - struct device_drv *drv = cgpu->drv; - const int thr_id = mythr->id; - int64_t hashes_done = 0; - - while (likely(!cgpu->shutdown)) { - struct timeval diff; - int64_t hashes; - - mythr->work_update = false; - - hashes = drv->scanwork(mythr); - - /* Reset the bool here in case the driver looks for it - * synchronously in the scanwork loop. */ - mythr->work_restart = false; - - if (unlikely(hashes == -1 )) { - applog(LOG_ERR, "%s %d failure, disabling!", drv->name, cgpu->device_id); - cgpu->deven = DEV_DISABLED; - dev_error(cgpu, REASON_THREAD_ZERO_HASH); - break; - } - - hashes_done += hashes; - cgtime(&tv_end); - timersub(&tv_end, &tv_start, &diff); - /* Update the hashmeter at most 5 times per second */ - if ((hashes_done && (diff.tv_sec > 0 || diff.tv_usec > 200000)) || - diff.tv_sec >= opt_log_interval) { - hashmeter(thr_id, &diff, hashes_done); - hashes_done = 0; - copy_time(&tv_start, &tv_end); - } - - if (unlikely(mythr->pause || cgpu->deven != DEV_ENABLED)) - mt_disable(mythr, thr_id, drv); - - if (mythr->work_update) - drv->update_work(cgpu); - } - cgpu->deven = DEV_DISABLED; -} - void *miner_thread(void *userdata) { struct thr_info *mythr = (struct thr_info *)userdata; @@ -8055,9 +7656,6 @@ void enable_device(struct cgpu_info *cgpu) #ifdef HAVE_CURSES adj_width(mining_threads, &dev_width); #endif - - rwlock_init(&cgpu->qlock); - cgpu->queued_work = NULL; } struct _cgpu_devid_counter { @@ -8068,8 +7666,8 @@ struct _cgpu_devid_counter { static void adjust_mostdevs(void) { - if (total_devices - zombie_devs > most_devices) - most_devices = total_devices - zombie_devs; + if (total_devices > most_devices) + most_devices = total_devices; } bool add_cgpu(struct cgpu_info *cgpu) @@ -8202,7 +7800,7 @@ static void restart_mining_threads(unsigned int new_n_threads) static void *restart_mining_threads_thread(void *userdata) { - restart_mining_threads((unsigned int) userdata); + restart_mining_threads((unsigned int) (intptr_t) userdata); return NULL; } diff --git a/util.c b/util.c index b3d2f0b3..34c4792e 100644 --- a/util.c +++ b/util.c @@ -52,8 +52,10 @@ bool successful_connect = false; static void keep_sockalive(SOCKETTYPE fd) { const int tcp_one = 1; +#ifdef __linux + const int tcp_keepidle = 45; +#endif #ifndef WIN32 - const int tcp_keepidle = 45; const int tcp_keepintvl = 30; int flags = fcntl(fd, F_GETFL, 0);