Merge commit 'f6a673a' into bfgminer

Conflicts:
	miner.c

deviceapi.c

@@ -489,7 +489,7 @@ void cgpu_setup_control_requests(struct cgpu_info * const cgpu)
 {
 	mutex_init(&cgpu->device_mutex);
 	notifier_init(cgpu->thr[0]->mutex_request);
-	pthread_cond_init(&cgpu->device_cond, NULL);
+	pthread_cond_init(&cgpu->device_cond, bfg_condattr);
 }
 
 void cgpu_request_control(struct cgpu_info * const cgpu)

miner.c

@@ -1052,7 +1052,7 @@ struct pool *add_pool(void)
 	mutex_init(&pool->last_work_lock);
 	mutex_init(&pool->pool_lock);
 	mutex_init(&pool->pool_test_lock);
-	if (unlikely(pthread_cond_init(&pool->cr_cond, NULL)))
+	if (unlikely(pthread_cond_init(&pool->cr_cond, bfg_condattr)))
 		quit(1, "Failed to pthread_cond_init in add_pool");
 	cglock_init(&pool->data_lock);
 	mutex_init(&pool->stratum_lock);
@@ -9127,7 +9127,6 @@ static struct work *hash_pop(void)
 {
 	struct work *work = NULL, *tmp;
 	int hc;
-	struct timespec ts;
 
 retry:
 	mutex_lock(stgd_lock);
@@ -9145,9 +9144,9 @@ retry:
 			staged_full = false;  // Let it fill up before triggering an underrun again
 			no_work = true;
 		}
-		ts = (struct timespec){ .tv_sec = opt_log_interval, };
 		pthread_cond_signal(&gws_cond);
-		if (ETIMEDOUT == pthread_cond_timedwait(&getq->cond, stgd_lock, &ts))
+		const struct timeval tv = { .tv_sec = opt_log_interval, };
+		if (ETIMEDOUT == bfg_cond_timedwait(&getq->cond, stgd_lock, &tv))
 		{
 			run_cmd(cmd_idle);
 			pthread_cond_signal(&gws_cond);
@@ -12287,10 +12286,10 @@ int main(int argc, char *argv[])
 	rwlock_init(&devices_lock);
 
 	mutex_init(&lp_lock);
-	if (unlikely(pthread_cond_init(&lp_cond, NULL)))
+	if (unlikely(pthread_cond_init(&lp_cond, bfg_condattr)))
 		quit(1, "Failed to pthread_cond_init lp_cond");
 
-	if (unlikely(pthread_cond_init(&gws_cond, NULL)))
+	if (unlikely(pthread_cond_init(&gws_cond, bfg_condattr)))
 		quit(1, "Failed to pthread_cond_init gws_cond");
 
 	notifier_init(submit_waiting_notifier);

util.c

@@ -882,7 +882,7 @@ struct thread_q *tq_new(void)
 		return NULL;
 
 	pthread_mutex_init(&tq->mutex, NULL);
-	pthread_cond_init(&tq->cond, NULL);
+	pthread_cond_init(&tq->cond, bfg_condattr);
 
 	return tq;
 }
@@ -1185,6 +1185,7 @@ void _now_is_not_set(__maybe_unused struct timeval *tv)
 void (*timer_set_now)(struct timeval *tv) = _now_is_not_set;
 void (*cgsleep_us_r)(cgtimer_t *, int64_t) = _cgsleep_us_r_nanosleep;
 
+static clockid_t bfg_timedwait_clk;
 #ifdef HAVE_CLOCK_GETTIME_MONOTONIC
 static clockid_t bfg_timer_clk;
 
@@ -1230,6 +1231,60 @@ bool _bfg_try_clock_gettime(clockid_t clk)
 }
 #endif
 
+int bfg_cond_timedwait(pthread_cond_t * restrict cond, pthread_mutex_t * restrict mutex, const struct timeval *tvp)
+{
+	struct timespec ts;
+	clock_gettime(bfg_timedwait_clk, &ts);
+	ts.tv_sec += tvp->tv_sec;
+	ts.tv_nsec += (long)tvp->tv_usec * 1000;
+	if (ts.tv_nsec > 1000000000L)
+	{
+		++ts.tv_sec;
+		ts.tv_nsec -= 1000000000L;
+	}
+	return pthread_cond_timedwait(cond, mutex, &ts);
+}
+
+pthread_condattr_t *bfg_condattr_()
+{
+	static pthread_condattr_t attr;
+	static bool initialized;
+	
+	if (unlikely(!initialized))
+	{
+		pthread_condattr_init(&attr);
+#ifdef HAVE_CLOCK_GETTIME_MONOTONIC
+#ifdef HAVE_CLOCK_GETTIME_MONOTONIC_RAW
+		if (!pthread_condattr_setclock(&attr, CLOCK_MONOTONIC_RAW))
+		{
+			applog(LOG_DEBUG, "Timers: Using %s for cond timedwait", "CLOCK_MONOTONIC_RAW");
+			bfg_timedwait_clk = CLOCK_MONOTONIC_RAW;
+		}
+		else
+#endif
+		if (!pthread_condattr_setclock(&attr, CLOCK_MONOTONIC))
+		{
+			applog(LOG_DEBUG, "Timers: Using %s for cond timedwait", "CLOCK_MONOTONIC");
+			bfg_timedwait_clk = CLOCK_MONOTONIC;
+		}
+		else
+#endif
+		if (!pthread_condattr_setclock(&attr, CLOCK_REALTIME))
+		{
+			applog(LOG_DEBUG, "Timers: Using %s for cond timedwait", "CLOCK_REALTIME");
+			bfg_timedwait_clk = CLOCK_REALTIME;
+		}
+		else
+		{
+			applog(LOG_DEBUG, "Timers: Cannot find a clock for cond timedwait");
+			return NULL;
+		}
+		initialized = true;
+	}
+	
+	return &attr;
+}
+
 static
 void bfg_init_time()
 {

util.h

@@ -220,6 +220,10 @@ int cgtimer_to_ms(cgtimer_t *cgt)
 	return (cgt->tv_sec * 1000) + (cgt->tv_usec / 1000);
 }
 
+extern int bfg_cond_timedwait(pthread_cond_t * restrict, pthread_mutex_t * restrict, const struct timeval *);
+extern pthread_condattr_t *bfg_condattr_();
+#define bfg_condattr (bfg_condattr_())
+
 #define cgtimer_sub(a, b, res)  timersub(a, b, res)
 double us_tdiff(struct timeval *end, struct timeval *start);
 double tdiff(struct timeval *end, struct timeval *start);