last bit of renaming to dispatch_workq 'namespace'

Author: dgrove-oss

src/workqueue/workqueue.c

@@ -135,12 +135,12 @@ typedef struct dispatch_workq_item_s {
 	void *func_arg;
 } dispatch_workq_item_s, *dispatch_workq_item_t;
 
-typedef struct dispatch_workqueue_s {
+typedef struct dispatch_workq_workqueue_s {
 	STAILQ_HEAD(,dispatch_workq_item_s) item_listhead;
 	dispatch_unfair_lock_s lock;
 	int priority;
 	bool overcommit;
-} dispatch_workqueue_s, *dispatch_workqueue_t;
+} dispatch_workq_workqueue_s, *dispatch_workq_workqueue_t;
 
 /*
  * The overcommit pool uses a simple coarse locking policy:
@@ -154,7 +154,7 @@ typedef struct dispatch_workqueue_s {
 typedef struct dispatch_workq_overcommit_pool_s {
 	uint32_t mask;
 	int num_spares;
-	dispatch_workqueue_t queues[WORKQ_NUM_PRIORITIES];
+	dispatch_workq_workqueue_t wqs[WORKQ_NUM_PRIORITIES];
 	pthread_mutex_t mutex;
 	pthread_cond_t spare_workers;
 } dispatch_workq_overcommit_pool_s, *dispatch_workq_overcommit_pool_t;
@@ -171,7 +171,7 @@ static dispatch_workq_overcommit_pool_s _dispatch_workq_overcommit_pool;
  */
 typedef struct dispatch_workq_pool_s {
 	volatile uint32_t mask;
-	dispatch_workqueue_t queues[WORKQ_NUM_PRIORITIES];
+	dispatch_workq_workqueue_t wqs[WORKQ_NUM_PRIORITIES];
 } dispatch_workq_pool_s, *dispatch_workq_pool_t;
 
 static dispatch_workq_pool_s _dispatch_workq_normal_pool;
@@ -209,10 +209,11 @@ _dispatch_workq_dealloc_item(dispatch_workq_item_t wi)
 
 
 static void
-_dispatch_workq_allocate_workqueues(dispatch_workqueue_t *queues, int num_queues, bool overcommit)
+_dispatch_workq_allocate_workqueues(dispatch_workq_workqueue_t *queues,
+		int num_queues, bool overcommit)
 {
 	for (int i=0; i<num_queues; i++) {
-		dispatch_workqueue_t wq;
+		dispatch_workq_workqueue_t wq;
 		wq = _dispatch_calloc(1, ROUND_UP_TO_CACHELINE_SIZE(sizeof(*wq)));
 
 		wq->priority = i;
@@ -271,7 +272,7 @@ _dispatch_workq_init_once(void *context DISPATCH_UNUSED)
 	_dispatch_workq_management_init();
 
 	// overcommit pool
-	_dispatch_workq_allocate_workqueues(_dispatch_workq_overcommit_pool.queues,
+	_dispatch_workq_allocate_workqueues(_dispatch_workq_overcommit_pool.wqs,
 			WORKQ_NUM_PRIORITIES, true);
 	r = pthread_mutex_init(&_dispatch_workq_overcommit_pool.mutex, NULL);
 	(void)dispatch_assume_zero(r);
@@ -280,7 +281,7 @@ _dispatch_workq_init_once(void *context DISPATCH_UNUSED)
 	(void)dispatch_assume_zero(r);
 
 	// normal pool
-	_dispatch_workq_allocate_workqueues(_dispatch_workq_normal_pool.queues,
+	_dispatch_workq_allocate_workqueues(_dispatch_workq_normal_pool.wqs,
 			WORKQ_NUM_PRIORITIES, false);
 
 	// create initial set of normal workers
@@ -291,24 +292,24 @@ _dispatch_workq_init_once(void *context DISPATCH_UNUSED)
 
 
 int
-dispatch_workq_get_wq(dispatch_workqueue_t *workqp,
+dispatch_workq_get_wq(dispatch_workq_workqueue_t *workqp,
 		int priority, int overcommit)
 {
 	dispatch_once_f(&_dispatch_workq_init_once_pred, NULL,
 					&_dispatch_workq_init_once);
 
 	dispatch_assert(priority >= 0 && priority < WORKQ_NUM_PRIORITIES);
 	if (overcommit) {
-		*workqp = _dispatch_workq_overcommit_pool.queues[priority];
+		*workqp = _dispatch_workq_overcommit_pool.wqs[priority];
 	} else {
-		*workqp = _dispatch_workq_normal_pool.queues[priority];
+		*workqp = _dispatch_workq_normal_pool.wqs[priority];
 	}
 
 	return 0;
 }
 
 int
-dispatch_workq_additem_np(dispatch_workqueue_t workq,
+dispatch_workq_additem_np(dispatch_workq_workqueue_t workq,
 		void (*item_func)(void *), void *item_arg)
 {
 	dispatch_workq_item_t wi = _dispatch_workq_alloc_item(item_func, item_arg);
@@ -348,7 +349,7 @@ static void
 _dispatch_workq_add_control_item(void *op_code)
 {
 	dispatch_workq_item_t wi = _dispatch_workq_alloc_item(NULL, op_code);
-	dispatch_workqueue_t workq = _dispatch_workq_normal_pool.queues[0];
+	dispatch_workq_workqueue_t workq = _dispatch_workq_normal_pool.wqs[0];
 	unsigned int wq_index_bit = 1; // highest priority queue
 
 	_dispatch_unfair_lock_lock(&workq->lock);
@@ -390,29 +391,30 @@ _dispatch_workq_overcommit_worker_main(void *context DISPATCH_UNUSED)
 {
 	int r;
 	sigset_t mask;
+	dispatch_workq_overcommit_pool_t oc_pool = &_dispatch_workq_overcommit_pool;
 
 	r = sigfillset(&mask);
 	(void)dispatch_assume_zero(r);
 	r = _dispatch_pthread_sigmask(SIG_BLOCK, &mask, NULL);
 	(void)dispatch_assume_zero(r);
 
-	r = pthread_mutex_lock(&_dispatch_workq_overcommit_pool.mutex);
+	r = pthread_mutex_lock(&oc_pool->mutex);
 	(void)dispatch_assume_zero(r);
 
 	for (;;) {
-		unsigned int idx = __builtin_ffs(_dispatch_workq_overcommit_pool.mask);
+		unsigned int idx = __builtin_ffs(oc_pool->mask);
 		if (idx > 0) {
-			dispatch_workqueue_t wq = _dispatch_workq_overcommit_pool.queues[idx - 1];
+			dispatch_workq_workqueue_t wq = oc_pool->wqs[idx - 1];
 			dispatch_workq_item_t work = STAILQ_FIRST(&wq->item_listhead);
 			if (work != NULL) {
 				/* Remove the first work item */
 				STAILQ_REMOVE_HEAD(&wq->item_listhead, item_entry);
 				if (STAILQ_EMPTY(&wq->item_listhead)) {
-					_dispatch_workq_overcommit_pool.mask &= ~(0x1 << wq->priority);
+					oc_pool->mask &= ~(0x1 << wq->priority);
 				}
 
 				/* Release pool mutex */
-				r = pthread_mutex_unlock(&_dispatch_workq_overcommit_pool.mutex);
+				r = pthread_mutex_unlock(&oc_pool->mutex);
 				(void)dispatch_assume_zero(r);
 
 				/* Execute the work item */
@@ -423,16 +425,15 @@ _dispatch_workq_overcommit_worker_main(void *context DISPATCH_UNUSED)
 				func(func_arg);
 
 				/* Acquire pool mutex */
-				r = pthread_mutex_lock(&_dispatch_workq_overcommit_pool.mutex);
+				r = pthread_mutex_lock(&oc_pool->mutex);
 				(void)dispatch_assume_zero(r);
 				continue;
 			}
 		}
 
 		/* Wait for more work to be available. */
-		_dispatch_workq_overcommit_pool.num_spares++;
-		r = pthread_cond_wait(&_dispatch_workq_overcommit_pool.spare_workers,
-				&_dispatch_workq_overcommit_pool.mutex);
+		oc_pool->num_spares++;
+		r = pthread_cond_wait(&oc_pool->spare_workers, &oc_pool->mutex);
 	}
 }
 
@@ -442,6 +443,7 @@ _dispatch_workq_normal_worker_main(void *context DISPATCH_UNUSED)
 {
 	int r;
 	sigset_t mask;
+	dispatch_workq_pool_t pool = &_dispatch_workq_normal_pool;
 
 	r = sigfillset(&mask);
 	(void)dispatch_assume_zero(r);
@@ -456,9 +458,9 @@ _dispatch_workq_normal_worker_main(void *context DISPATCH_UNUSED)
 	_dispatch_debug("workq: worker successfully registered");
 
 	for (;;) {
-		int idx = __builtin_ffs(os_atomic_load(&_dispatch_workq_normal_pool.mask, relaxed));
+		int idx = __builtin_ffs(os_atomic_load(&pool->mask, relaxed));
 		if (idx > 0) {
-			dispatch_workqueue_t wq = _dispatch_workq_normal_pool.queues[idx - 1];
+			dispatch_workq_workqueue_t wq = pool->wqs[idx - 1];
 			_dispatch_unfair_lock_lock(&wq->lock);
 			dispatch_workq_item_t work = STAILQ_FIRST(&wq->item_listhead);
 			if (unlikely(work == NULL)) {
@@ -469,7 +471,7 @@ _dispatch_workq_normal_worker_main(void *context DISPATCH_UNUSED)
 				// found work: remove it.
 				STAILQ_REMOVE_HEAD(&wq->item_listhead, item_entry);
 				if (STAILQ_EMPTY(&wq->item_listhead)) {
-					os_atomic_and(&_dispatch_workq_normal_pool.mask, ~(0x1 << wq->priority), relaxed);
+					os_atomic_and(&pool->mask, ~(0x1 << wq->priority), relaxed);
 				}
 				_dispatch_unfair_lock_unlock(&wq->lock);
 
@@ -501,7 +503,7 @@ _dispatch_workq_normal_worker_main(void *context DISPATCH_UNUSED)
 		for (int i=0; i<5 && !found_work; i++) {
 			r = pthread_yield();
 			(void)dispatch_assume_zero(r);
-			found_work = os_atomic_load(&_dispatch_workq_normal_pool.mask, relaxed) != 0;
+			found_work = os_atomic_load(&pool->mask, relaxed) != 0;
 		}
 
 		if (!found_work) {

src/workqueue/workqueue_internal.h

@@ -27,7 +27,7 @@
 #ifndef __DISPATCH_WORKQUEUE_INTERNAL__
 #define __DISPATCH_WORKQUEUE_INTERNAL__
 
-typedef struct dispatch_workqueue_s *pthread_workqueue_t;
+typedef struct dispatch_workq_workqueue_s *pthread_workqueue_t;
 
 /* Work queue priority attributes. */
 #define WORKQ_HIGH_PRIOQUEUE             0