Test larger quantum and more threads

lib/dns/dispatch.c

@@ -2873,7 +2873,7 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 	dns_dispatch_t *disp;
 	isc_socket_t *sock = NULL;
 	int i = 0;
-	dup_socket = NULL;
+
 	/*
 	 * dispatch_allocate() checks mgr for us.
 	 */
@@ -2950,9 +2950,7 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 			}
 			goto kill_socket;
 		}
-		char n[32];
-		sprintf(n, "UDPD-%d", i);
-		isc_task_setname(disp->task[i], n, disp);
+		isc_task_setname(disp->task[i], "udpdispatch", disp);
 	}
 
 	disp->ctlevent = isc_event_allocate(mgr->mctx, disp,

lib/isc/include/isc/task.h

@@ -208,8 +208,6 @@ isc_task_detach(isc_task_t **taskp);
 
 void
 isc_task_send(isc_task_t *task, isc_event_t **eventp);
-void
-isc_task_sendto(isc_task_t *task, isc_event_t **eventp, int id);
 /*%<
  * Send '*event' to 'task'.
  *

lib/isc/random.c

@@ -62,7 +62,7 @@
  */
 #include "xoshiro128starstar.c"
 
-static thread_local isc_once_t isc_random_once = ISC_ONCE_INIT;
+static isc_once_t isc_random_once = ISC_ONCE_INIT;
 
 static void
 isc_random_initialize(void) {

lib/isc/task.c

@@ -19,9 +19,7 @@
 #include <config.h>
 
 #include <stdbool.h>
-#include <sched.h>
 
-#include <isc/atomic.h>
 #include <isc/app.h>
 #include <isc/condition.h>
 #include <isc/event.h>
@@ -55,7 +53,6 @@
  * is expected to have a separate manager; no "worker threads" are shared by
  * the application threads.
  */
-// #define ISC_TASK_TRACE
 #ifdef ISC_TASK_TRACE
 #define XTRACE(m)		fprintf(stderr, "task %p thread %lu: %s\n", \
 				       task, isc_thread_self(), (m))
@@ -107,7 +104,6 @@ struct isc__task {
 	isc_time_t			tnow;
 	char				name[16];
 	void *				tag;
-	int				c;
 	/* Locked by task manager lock. */
 	LINK(isc__task_t)		link;
 	LINK(isc__task_t)		ready_link;
@@ -130,20 +126,19 @@ struct isc__taskmgr {
 	isc_taskmgr_t			common;
 	isc_mem_t *			mctx;
 	isc_mutex_t			lock;
-	isc_mutex_t			*locks;
 	unsigned int			workers;
 	isc_thread_t *			threads;
 	/* Locked by task manager lock. */
 	unsigned int			default_quantum;
 	LIST(isc__task_t)		tasks;
-	isc__tasklist_t			*ready_tasks;
-	isc__tasklist_t			*ready_priority_tasks;
+	isc__tasklist_t			ready_tasks;
+	isc__tasklist_t			ready_priority_tasks;
 	isc_taskmgrmode_t		mode;
-	isc_condition_t			*work_available;
+	isc_condition_t			work_available;
 	isc_condition_t			exclusive_granted;
 	isc_condition_t			paused;
-	int32_t			tasks_running;
-	int32_t			tasks_ready;
+	unsigned int			tasks_running;
+	unsigned int			tasks_ready;
 	bool			pause_requested;
 	bool			exclusive_requested;
 	bool			exiting;
@@ -164,7 +159,7 @@ isc__taskmgr_resume(isc_taskmgr_t *manager0);
 
 
 #define DEFAULT_TASKMGR_QUANTUM		10
-#define DEFAULT_DEFAULT_QUANTUM		5
+#define DEFAULT_DEFAULT_QUANTUM		30
 #define FINISHED(m)			((m)->exiting && EMPTY((m)->tasks))
 
 /*%
@@ -180,13 +175,13 @@ isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0);
 isc_result_t
 isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp);
 static inline bool
-empty_readyq(isc__taskmgr_t *manager, int c);
+empty_readyq(isc__taskmgr_t *manager);
 
 static inline isc__task_t *
-pop_readyq(isc__taskmgr_t *manager, int c);
+pop_readyq(isc__taskmgr_t *manager);
 
 static inline void
-push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c);
+push_readyq(isc__taskmgr_t *manager, isc__task_t *task);
 
 /***
  *** Tasks.
@@ -195,6 +190,7 @@ push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c);
 static void
 task_finished(isc__task_t *task) {
 	isc__taskmgr_t *manager = task->manager;
+
 	REQUIRE(EMPTY(task->events));
 	REQUIRE(task->nevents == 0);
 	REQUIRE(EMPTY(task->on_shutdown));
@@ -205,7 +201,6 @@ task_finished(isc__task_t *task) {
 
 	LOCK(&manager->lock);
 	UNLINK(manager->tasks, task, link);
-	UNLOCK(&manager->lock);
 	if (FINISHED(manager)) {
 		/*
 		 * All tasks have completed and the
@@ -213,12 +208,10 @@ task_finished(isc__task_t *task) {
 		 * any idle worker threads so they
 		 * can exit.
 		 */
-		for (unsigned i=0; i<manager->workers; i++) {
-			LOCK(&manager->locks[i]);
-			BROADCAST(&manager->work_available[i]);
-			UNLOCK(&manager->locks[i]);
-		}
+		BROADCAST(&manager->work_available);
 	}
+	UNLOCK(&manager->lock);
+
 	DESTROYLOCK(&task->lock);
 	task->common.impmagic = 0;
 	task->common.magic = 0;
@@ -242,7 +235,6 @@ isc_task_create(isc_taskmgr_t *manager0, unsigned int quantum,
 		return (ISC_R_NOMEMORY);
 	XTRACE("isc_task_create");
 	task->manager = manager;
-	task->c = -1;
 	result = isc_mutex_init(&task->lock);
 	if (result != ISC_R_SUCCESS) {
 		isc_mem_put(manager->mctx, task, sizeof(*task));
@@ -359,15 +351,12 @@ task_ready(isc__task_t *task) {
 	REQUIRE(task->state == task_state_ready);
 
 	XTRACE("task_ready");
-	task->c = sched_getcpu() % task->manager->workers;
-//	printf("Pushing onto %d\n", task->c);
-	LOCK(&manager->locks[task->c]);
-	push_readyq(manager, task, task->c);
-	if (manager->mode == isc_taskmgrmode_normal || has_privilege) {
-//		printf("Broadcasting %d\n", task->c);
-		BROADCAST(&manager->work_available[task->c]);
-	}
-	UNLOCK(&manager->locks[task->c]);
+
+	LOCK(&manager->lock);
+	push_readyq(manager, task);
+	if (manager->mode == isc_taskmgrmode_normal || has_privilege)
+		SIGNAL(&manager->work_available);
+	UNLOCK(&manager->lock);
 }
 
 static inline bool
@@ -445,7 +434,6 @@ task_send(isc__task_t *task, isc_event_t **eventp) {
 	if (task->state == task_state_idle) {
 		was_idle = true;
 		INSIST(EMPTY(task->events));
-		task->c = sched_getcpu() % task->manager->workers;
 		task->state = task_state_ready;
 	}
 	INSIST(task->state == task_state_ready ||
@@ -497,7 +485,6 @@ isc_task_send(isc_task_t *task0, isc_event_t **eventp) {
 		 */
 		task_ready(task);
 	}
-	pthread_yield();
 }
 
 void
@@ -520,7 +507,7 @@ isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
 	idle1 = task_send(task, eventp);
 	idle2 = task_detach(task);
 	UNLOCK(&task->lock);
-	
+
 	/*
 	 * If idle1, then idle2 shouldn't be true as well since we're holding
 	 * the task lock, and thus the task cannot switch from ready back to
@@ -530,7 +517,7 @@ isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
 
 	if (idle1 || idle2)
 		task_ready(task);
-	pthread_yield();
+
 	*taskp = NULL;
 }
 
@@ -842,13 +829,13 @@ isc_task_getcurrenttimex(isc_task_t *task0, isc_time_t *t) {
  * Caller must hold the task manager lock.
  */
 static inline bool
-empty_readyq(isc__taskmgr_t *manager, int c) {
+empty_readyq(isc__taskmgr_t *manager) {
 	isc__tasklist_t queue;
 
 	if (manager->mode == isc_taskmgrmode_normal)
-		queue = manager->ready_tasks[c];
+		queue = manager->ready_tasks;
 	else
-		queue = manager->ready_priority_tasks[c];
+		queue = manager->ready_priority_tasks;
 
 	return (EMPTY(queue));
 }
@@ -862,18 +849,18 @@ empty_readyq(isc__taskmgr_t *manager, int c) {
  * Caller must hold the task manager lock.
  */
 static inline isc__task_t *
-pop_readyq(isc__taskmgr_t *manager, int c) {
+pop_readyq(isc__taskmgr_t *manager) {
 	isc__task_t *task;
 
 	if (manager->mode == isc_taskmgrmode_normal)
-		task = HEAD(manager->ready_tasks[c]);
+		task = HEAD(manager->ready_tasks);
 	else
-		task = HEAD(manager->ready_priority_tasks[c]);
+		task = HEAD(manager->ready_priority_tasks);
 
 	if (task != NULL) {
-		DEQUEUE(manager->ready_tasks[c], task, ready_link);
+		DEQUEUE(manager->ready_tasks, task, ready_link);
 		if (ISC_LINK_LINKED(task, ready_priority_link))
-			DEQUEUE(manager->ready_priority_tasks[c], task,
+			DEQUEUE(manager->ready_priority_tasks, task,
 				ready_priority_link);
 	}
 
@@ -887,16 +874,16 @@ pop_readyq(isc__taskmgr_t *manager, int c) {
  * Caller must hold the task manager lock.
  */
 static inline void
-push_readyq(isc__taskmgr_t *manager, isc__task_t *task, int c) {
-	ENQUEUE(manager->ready_tasks[c], task, ready_link);
+push_readyq(isc__taskmgr_t *manager, isc__task_t *task) {
+	ENQUEUE(manager->ready_tasks, task, ready_link);
 	if ((task->flags & TASK_F_PRIVILEGED) != 0)
-		ENQUEUE(manager->ready_priority_tasks[c], task,
+		ENQUEUE(manager->ready_priority_tasks, task,
 			ready_priority_link);
-	isc_atomic_xadd(&manager->tasks_ready, 1);
+	manager->tasks_ready++;
 }
 
 static void
-dispatch(isc__taskmgr_t *manager, int c) {
+dispatch(isc__taskmgr_t *manager) {
 	isc__task_t *task;
 
 	REQUIRE(VALID_MANAGER(manager));
@@ -950,7 +937,9 @@ dispatch(isc__taskmgr_t *manager, int c) {
 	 * For N iterations of the loop, this code does N+1 locks and N+1
 	 * unlocks.  The while expression is always protected by the lock.
 	 */
-	
+
+	LOCK(&manager->lock);
+
 	while (!FINISHED(manager)) {
 		/*
 		 * For reasons similar to those given in the comment in
@@ -962,16 +951,13 @@ dispatch(isc__taskmgr_t *manager, int c) {
 		 * If a pause has been requested, don't do any work
 		 * until it's been released.
 		 */
-		LOCK(&manager->locks[c]);
-		while ((empty_readyq(manager, c) || manager->pause_requested ||
+		while ((empty_readyq(manager) || manager->pause_requested ||
 			manager->exclusive_requested) && !FINISHED(manager))
 		{
 			XTHREADTRACE(isc_msgcat_get(isc_msgcat,
 						    ISC_MSGSET_GENERAL,
 						    ISC_MSG_WAIT, "wait"));
-//			printf("WAITING %d %d %d %d\n", c, empty_readyq(manager, c), manager->pause_requested, manager->exclusive_requested);
-			WAIT(&manager->work_available[c], &manager->locks[c]);
-//			printf("DONEWAITING %d %d %d %d\n", c, empty_readyq(manager, c), manager->pause_requested, manager->exclusive_requested);
+			WAIT(&manager->work_available, &manager->lock);
 			XTHREADTRACE(isc_msgcat_get(isc_msgcat,
 						    ISC_MSGSET_TASK,
 						    ISC_MSG_AWAKE, "awake"));
@@ -979,7 +965,7 @@ dispatch(isc__taskmgr_t *manager, int c) {
 		XTHREADTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_TASK,
 					    ISC_MSG_WORKING, "working"));
 
-		task = pop_readyq(manager, c);
+		task = pop_readyq(manager);
 		if (task != NULL) {
 			unsigned int dispatch_count = 0;
 			bool done = false;
@@ -994,21 +980,15 @@ dispatch(isc__taskmgr_t *manager, int c) {
 			 * have a task to do.  We must reacquire the manager
 			 * lock before exiting the 'if (task != NULL)' block.
 			 */
-			UNLOCK(&manager->locks[c]);
-			LOCK(&manager->lock);
 			manager->tasks_ready--;
 			manager->tasks_running++;
 			UNLOCK(&manager->lock);
-//			isc_atomic_xadd(&manager->tasks_ready, -1);
-//			isc_atomic_xadd(&manager->tasks_running, 1);
 
 			LOCK(&task->lock);
 			INSIST(task->state == task_state_ready);
 			task->state = task_state_running;
-			task->c = c;
 			XTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 					      ISC_MSG_RUNNING, "running"));
-			XTRACE(task->name);
 			TIME_NOW(&task->tnow);
 			task->now = isc_time_seconds(&task->tnow);
 			do {
@@ -1024,7 +1004,6 @@ dispatch(isc__taskmgr_t *manager, int c) {
 							    ISC_MSGSET_TASK,
 							    ISC_MSG_EXECUTE,
 							    "execute action"));
-					XTRACE(task->name);
 					if (event->ev_action != NULL) {
 						UNLOCK(&task->lock);
 						(event->ev_action)(
@@ -1114,6 +1093,7 @@ dispatch(isc__taskmgr_t *manager, int c) {
 
 			if (finished)
 				task_finished(task);
+
 			LOCK(&manager->lock);
 			manager->tasks_running--;
 			if (manager->exclusive_requested &&
@@ -1123,7 +1103,6 @@ dispatch(isc__taskmgr_t *manager, int c) {
 				   manager->tasks_running == 0) {
 				SIGNAL(&manager->paused);
 			}
-			UNLOCK(&manager->lock);
 			if (requeue) {
 				/*
 				 * We know we're awake, so we don't have
@@ -1144,9 +1123,7 @@ dispatch(isc__taskmgr_t *manager, int c) {
 				 * were usually nonempty, the 'optimization'
 				 * might even hurt rather than help.
 				 */
-				LOCK(&manager->locks[c]);
-				push_readyq(manager, task, c);
-				UNLOCK(&manager->locks[c]);
+				push_readyq(manager, task);
 			}
 		}
 
@@ -1156,40 +1133,27 @@ dispatch(isc__taskmgr_t *manager, int c) {
 		 * we're stuck.  Automatically drop privileges at that
 		 * point and continue with the regular ready queue.
 		 */
-		if (manager->tasks_running == 0 && empty_readyq(manager, c)) {
-			if (manager->mode != isc_taskmgrmode_normal) {
-				manager->mode = isc_taskmgrmode_normal;
-				for (unsigned i=0; i<manager->workers; i++) {
-					if (i != (unsigned)c)
-						LOCK(&manager->locks[i]);
-					BROADCAST(&manager->work_available[i]);
-					if (i != (unsigned)c)
-						UNLOCK(&manager->locks[i]);
-				}
-			}
+		if (manager->tasks_running == 0 && empty_readyq(manager)) {
+			manager->mode = isc_taskmgrmode_normal;
+			if (!empty_readyq(manager))
+				BROADCAST(&manager->work_available);
 		}
 	}
-}
 
-typedef struct st {
-	isc__taskmgr_t *manager;
-	int c;
-} stt;
+	UNLOCK(&manager->lock);
+}
 
 static isc_threadresult_t
 #ifdef _WIN32
 WINAPI
 #endif
 run(void *uap) {
-	stt *st = uap;
-	isc__taskmgr_t *manager = st->manager;
-	int c = st->c;
-	free(st);
+	isc__taskmgr_t *manager = uap;
 
 	XTHREADTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 				    ISC_MSG_STARTING, "starting"));
 
-	dispatch(manager, c);
+	dispatch(manager);
 
 	XTHREADTRACE(isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
 				    ISC_MSG_EXITING, "exiting"));
@@ -1206,7 +1170,7 @@ manager_free(isc__taskmgr_t *manager) {
 	isc_mem_t *mctx;
 
 	(void)isc_condition_destroy(&manager->exclusive_granted);
-	(void)isc_condition_destroy(&manager->work_available[0]);
+	(void)isc_condition_destroy(&manager->work_available);
 	(void)isc_condition_destroy(&manager->paused);
 	isc_mem_free(manager->mctx, manager->threads);
 	DESTROYLOCK(&manager->lock);
@@ -1256,6 +1220,14 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 		result = ISC_R_NOMEMORY;
 		goto cleanup_lock;
 	}
+	if (isc_condition_init(&manager->work_available) != ISC_R_SUCCESS) {
+		UNEXPECTED_ERROR(__FILE__, __LINE__,
+				 "isc_condition_init() %s",
+				 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
+						ISC_MSG_FAILED, "failed"));
+		result = ISC_R_UNEXPECTED;
+		goto cleanup_threads;
+	}
 	if (isc_condition_init(&manager->exclusive_granted) != ISC_R_SUCCESS) {
 		UNEXPECTED_ERROR(__FILE__, __LINE__,
 				 "isc_condition_init() %s",
@@ -1276,10 +1248,8 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 		default_quantum = DEFAULT_DEFAULT_QUANTUM;
 	manager->default_quantum = default_quantum;
 	INIT_LIST(manager->tasks);
-	manager->ready_tasks = malloc(workers * sizeof(isc__tasklist_t));
-	manager->locks = malloc(workers * sizeof(isc_mutex_t));
-	manager->work_available = malloc(workers * sizeof(isc_condition_t));
-	manager->ready_priority_tasks = malloc(workers * sizeof(isc__tasklist_t));
+	INIT_LIST(manager->ready_tasks);
+	INIT_LIST(manager->ready_priority_tasks);
 	manager->tasks_running = 0;
 	manager->tasks_ready = 0;
 	manager->exclusive_requested = false;
@@ -1294,34 +1264,16 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
 	 * Start workers.
 	 */
 	for (i = 0; i < workers; i++) {
-		INIT_LIST(manager->ready_tasks[i]);
-		INIT_LIST(manager->ready_priority_tasks[i]);
-		isc_mutex_init(&manager->locks[i]);
-		if (isc_condition_init(&manager->work_available[i]) != ISC_R_SUCCESS) {
-			UNEXPECTED_ERROR(__FILE__, __LINE__,
-					 "isc_condition_init() %s",
-					 isc_msgcat_get(isc_msgcat, ISC_MSGSET_GENERAL,
-							ISC_MSG_FAILED, "failed"));
-			result = ISC_R_UNEXPECTED;
-			goto cleanup_threads;
+		if (isc_thread_create(run, manager,
+				      &manager->threads[manager->workers]) ==
+		    ISC_R_SUCCESS) {
+			char name[16];	/* thread name limit on Linux */
+			snprintf(name, sizeof(name), "isc-worker%04u", i);
+			isc_thread_setname(manager->threads[manager->workers],
+					   name);
+			manager->workers++;
+			started++;
 		}
-		stt *st = malloc(sizeof(stt));
-		st->manager = manager;
-		st->c = i;
-		if (isc_thread_create(run, st,
-				      &manager->threads[i]) != ISC_R_SUCCESS) {
-			goto cleanup_threads;
-		}
-		char name[16];	/* thread name limit on Linux */
-		snprintf(name, sizeof(name), "isc-worker%04u", i);
-		isc_thread_setname(manager->threads[manager->workers],
-				   name);
-		cpu_set_t cpuset;
-		CPU_ZERO(&cpuset);
-	        CPU_SET(i, &cpuset);
-	        pthread_setaffinity_np(manager->threads[i], sizeof(cpu_set_t), &cpuset);
-		manager->workers++;
-		started++;
 	}
 	UNLOCK(&manager->lock);
 
@@ -1338,7 +1290,7 @@ isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
  cleanup_exclusivegranted:
 	(void)isc_condition_destroy(&manager->exclusive_granted);
  cleanup_workavailable:
-	(void)isc_condition_destroy(&manager->work_available[0]);
+	(void)isc_condition_destroy(&manager->work_available);
  cleanup_threads:
 	isc_mem_free(mctx, manager->threads);
  cleanup_lock:
@@ -1410,7 +1362,7 @@ isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
 	     task = NEXT(task, link)) {
 		LOCK(&task->lock);
 		if (task_shutdown(task))
-			push_readyq(manager, task, 0);
+			push_readyq(manager, task);
 		UNLOCK(&task->lock);
 	}
 	/*
@@ -1418,7 +1370,7 @@ isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
 	 * there's work left to do, and if there are already no tasks left
 	 * it will cause the workers to see manager->exiting.
 	 */
-	BROADCAST(&manager->work_available[0]);
+	BROADCAST(&manager->work_available);
 	UNLOCK(&manager->lock);
 
 	/*
@@ -1469,7 +1421,7 @@ isc__taskmgr_resume(isc_taskmgr_t *manager0) {
 	LOCK(&manager->lock);
 	if (manager->pause_requested) {
 		manager->pause_requested = false;
-		BROADCAST(&manager->work_available[0]); // TODO
+		BROADCAST(&manager->work_available);
 	}
 	UNLOCK(&manager->lock);
 }
@@ -1541,12 +1493,8 @@ isc_task_endexclusive(isc_task_t *task0) {
 	LOCK(&manager->lock);
 	REQUIRE(manager->exclusive_requested);
 	manager->exclusive_requested = false;
+	BROADCAST(&manager->work_available);
 	UNLOCK(&manager->lock);
-	for (unsigned i=0; i < manager->workers; i++) {
-		LOCK(&manager->locks[i]);
-		BROADCAST(&manager->work_available[i]);
-		UNLOCK(&manager->locks[i]);
-	}
 }
 
 void
@@ -1566,17 +1514,15 @@ isc_task_setprivilege(isc_task_t *task0, bool priv) {
 
 	if (priv == oldpriv)
 		return;
-	if (task->c == -1) {
-		task->c = sched_getcpu() % task->manager->workers;
-	}
-	LOCK(&manager->locks[task->c]);
+
+	LOCK(&manager->lock);
 	if (priv && ISC_LINK_LINKED(task, ready_link))
-		ENQUEUE(manager->ready_priority_tasks[task->c], task,
+		ENQUEUE(manager->ready_priority_tasks, task,
 			ready_priority_link);
 	else if (!priv && ISC_LINK_LINKED(task, ready_priority_link))
-		DEQUEUE(manager->ready_priority_tasks[task->c], task,
+		DEQUEUE(manager->ready_priority_tasks, task,
 			ready_priority_link);
-	UNLOCK(&manager->locks[task->c]);
+	UNLOCK(&manager->lock);
 }
 
 bool

lib/isc/xoshiro128starstar.c

@@ -60,7 +60,7 @@ static volatile HANDLE _mutex = NULL;
 #else /* defined(_WIN32) || defined(_WIN64) */
 
 #include <pthread.h>
-//static pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t _mutex = PTHREAD_MUTEX_INITIALIZER;
 #define _LOCK()   pthread_mutex_lock(&_mutex)
 #define _UNLOCK() pthread_mutex_unlock(&_mutex)
 #endif /* defined(_WIN32) || defined(_WIN64) */
@@ -69,13 +69,13 @@ static inline uint32_t rotl(const uint32_t x, int k) {
 	return (x << k) | (x >> (32 - k));
 }
 
-static thread_local uint32_t seed[4];
+static uint32_t seed[4];
 
 static inline uint32_t
 next(void) {
 	uint32_t result_starstar, t;
 
-//	_LOCK();
+	_LOCK();
 
 	result_starstar = rotl(seed[0] * 5, 7) * 9;
 	t = seed[1] << 9;
@@ -89,7 +89,7 @@ next(void) {
 
 	seed[3] = rotl(seed[3], 11);
 
-//	_UNLOCK();
+	_UNLOCK();
 
 	return (result_starstar);
 }

lib/ns/client.c

@@ -1048,7 +1048,6 @@ ns_client_sendraw(ns_client_t *client, dns_message_t *message) {
 	ns_client_next(client, result);
 }
 
-#ifdef PSEUDOSEND
 static void
 client_pseudosend(ns_client_t *client, uint16_t id) {
 	isc_result_t result;
@@ -1091,7 +1090,6 @@ done:
 	ns_client_next(client, result);
 
 }
-#endif
 
 static void
 client_send(ns_client_t *client) {
@@ -2447,10 +2445,9 @@ ns__client_request(isc_task_t *task, isc_event_t *event) {
 		ns_client_next(client, result);
 		return;
 	}
-#ifdef PSEUDOSEND
 	client_pseudosend(client, id);
 	return; 
-#endif
+
 	/*
 	 * The client object handles requests, not responses.
 	 * If this is a UDP response, forward it to the dispatcher.