dispatch_workq_workqueue ==> dispatch_workq_context

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_workq_workqueue_s {
+typedef struct dispatch_workq_context_s {
 	STAILQ_HEAD(,dispatch_workq_item_s) item_listhead;
 	dispatch_unfair_lock_s lock;
 	int priority;
 	bool overcommit;
-} dispatch_workq_workqueue_s, *dispatch_workq_workqueue_t;
+} dispatch_workq_context_s, *dispatch_workq_context_t;
 
 /*
  * The overcommit pool uses a simple coarse locking policy:
@@ -154,7 +154,7 @@ typedef struct dispatch_workq_workqueue_s {
 typedef struct dispatch_workq_overcommit_pool_s {
 	uint32_t mask;
 	int num_spares;
-	dispatch_workq_workqueue_t wqs[WORKQ_NUM_PRIORITIES];
+	dispatch_workq_context_t contexts[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_workq_workqueue_t wqs[WORKQ_NUM_PRIORITIES];
+	dispatch_workq_context_t contexts[WORKQ_NUM_PRIORITIES];
 } dispatch_workq_pool_s, *dispatch_workq_pool_t;
 
 static dispatch_workq_pool_s _dispatch_workq_normal_pool;
@@ -209,18 +209,18 @@ _dispatch_workq_dealloc_item(dispatch_workq_item_t wi)
 
 
 static void
-_dispatch_workq_allocate_workqueues(dispatch_workq_workqueue_t *queues,
+_dispatch_workq_allocate_contexts(dispatch_workq_context_t *contexts,
 		int num_queues, bool overcommit)
 {
 	for (int i=0; i<num_queues; i++) {
-		dispatch_workq_workqueue_t wq;
-		wq = _dispatch_calloc(1, ROUND_UP_TO_CACHELINE_SIZE(sizeof(*wq)));
+		dispatch_workq_context_t ctx;
+		ctx = _dispatch_calloc(1, ROUND_UP_TO_CACHELINE_SIZE(sizeof(*ctx)));
 
-		wq->priority = i;
-		wq->overcommit = overcommit;
-		STAILQ_INIT(&wq->item_listhead);
+		ctx->priority = i;
+		ctx->overcommit = overcommit;
+		STAILQ_INIT(&ctx->item_listhead);
 
-		queues[i] = wq;
+		contexts[i] = ctx;
 	}
 }
 
@@ -272,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.wqs,
+	_dispatch_workq_allocate_contexts(_dispatch_workq_overcommit_pool.contexts,
 			WORKQ_NUM_PRIORITIES, true);
 	r = pthread_mutex_init(&_dispatch_workq_overcommit_pool.mutex, NULL);
 	(void)dispatch_assume_zero(r);
@@ -281,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.wqs,
+	_dispatch_workq_allocate_contexts(_dispatch_workq_normal_pool.contexts,
 			WORKQ_NUM_PRIORITIES, false);
 
 	// create initial set of normal workers
@@ -292,33 +292,33 @@ _dispatch_workq_init_once(void *context DISPATCH_UNUSED)
 
 
 int
-dispatch_workq_get_wq(dispatch_workq_workqueue_t *workqp,
+dispatch_workq_get_wq(dispatch_workq_context_t *ctxp,
 		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.wqs[priority];
+		*ctxp = _dispatch_workq_overcommit_pool.contexts[priority];
 	} else {
-		*workqp = _dispatch_workq_normal_pool.wqs[priority];
+		*ctxp = _dispatch_workq_normal_pool.contexts[priority];
 	}
 
 	return 0;
 }
 
 int
-dispatch_workq_additem_np(dispatch_workq_workqueue_t workq,
+dispatch_workq_additem_np(dispatch_workq_context_t ctx,
 		void (*item_func)(void *), void *item_arg)
 {
 	dispatch_workq_item_t wi = _dispatch_workq_alloc_item(item_func, item_arg);
-	unsigned int wq_index_bit = (0x1 << workq->priority);
+	unsigned int wq_index_bit = (0x1 << ctx->priority);
 
-	if (unlikely(workq->overcommit)) {
+	if (unlikely(ctx->overcommit)) {
 		// overcommit pool uses trival concurrency control: all operations done holding pool mutex
 		pthread_mutex_lock(&_dispatch_workq_overcommit_pool.mutex);
-		STAILQ_INSERT_TAIL(&workq->item_listhead, wi, item_entry);
+		STAILQ_INSERT_TAIL(&ctx->item_listhead, wi, item_entry);
 		_dispatch_workq_overcommit_pool.mask |= wq_index_bit;
 		if (_dispatch_workq_overcommit_pool.num_spares > 0) {
 			pthread_cond_signal(&_dispatch_workq_overcommit_pool.spare_workers);
@@ -329,12 +329,12 @@ dispatch_workq_additem_np(dispatch_workq_workqueue_t workq,
 		pthread_mutex_unlock(&_dispatch_workq_overcommit_pool.mutex);
 	} else {
 		// normal pool uses finer-grained wq locking and atomic memory ops.
-		_dispatch_unfair_lock_lock(&workq->lock);
-		if (STAILQ_EMPTY(&workq->item_listhead)) {
+		_dispatch_unfair_lock_lock(&ctx->lock);
+		if (STAILQ_EMPTY(&ctx->item_listhead)) {
 			os_atomic_or(&_dispatch_workq_normal_pool.mask, wq_index_bit, relaxed);
 		}
-		STAILQ_INSERT_TAIL(&workq->item_listhead, wi, item_entry);
-		_dispatch_unfair_lock_unlock(&workq->lock);
+		STAILQ_INSERT_TAIL(&ctx->item_listhead, wi, item_entry);
+		_dispatch_unfair_lock_unlock(&ctx->lock);
 
 		if (unlikely(_dispatch_workq_runnable_workers < _dispatch_workq_max_runnable_workers)) {
 			_dispatch_workq_work_added();
@@ -349,15 +349,15 @@ static void
 _dispatch_workq_add_control_item(void *op_code)
 {
 	dispatch_workq_item_t wi = _dispatch_workq_alloc_item(NULL, op_code);
-	dispatch_workq_workqueue_t workq = _dispatch_workq_normal_pool.wqs[0];
+	dispatch_workq_context_t ctx = _dispatch_workq_normal_pool.contexts[0];
 	unsigned int wq_index_bit = 1; // highest priority queue
 
-	_dispatch_unfair_lock_lock(&workq->lock);
-	if (STAILQ_EMPTY(&workq->item_listhead)) {
+	_dispatch_unfair_lock_lock(&ctx->lock);
+	if (STAILQ_EMPTY(&ctx->item_listhead)) {
 		os_atomic_or(&_dispatch_workq_normal_pool.mask, wq_index_bit, relaxed);
 	}
-	STAILQ_INSERT_TAIL(&workq->item_listhead, wi, item_entry);
-	_dispatch_unfair_lock_unlock(&workq->lock);
+	STAILQ_INSERT_TAIL(&ctx->item_listhead, wi, item_entry);
+	_dispatch_unfair_lock_unlock(&ctx->lock);
 
 	if (unlikely(_dispatch_workq_runnable_workers < _dispatch_workq_max_runnable_workers)) {
 		_dispatch_workq_work_added();
@@ -404,13 +404,13 @@ _dispatch_workq_overcommit_worker_main(void *context DISPATCH_UNUSED)
 	for (;;) {
 		unsigned int idx = __builtin_ffs(oc_pool->mask);
 		if (idx > 0) {
-			dispatch_workq_workqueue_t wq = oc_pool->wqs[idx - 1];
-			dispatch_workq_item_t work = STAILQ_FIRST(&wq->item_listhead);
+			dispatch_workq_context_t ctx = oc_pool->contexts[idx - 1];
+			dispatch_workq_item_t work = STAILQ_FIRST(&ctx->item_listhead);
 			if (work != NULL) {
 				/* Remove the first work item */
-				STAILQ_REMOVE_HEAD(&wq->item_listhead, item_entry);
-				if (STAILQ_EMPTY(&wq->item_listhead)) {
-					oc_pool->mask &= ~(0x1 << wq->priority);
+				STAILQ_REMOVE_HEAD(&ctx->item_listhead, item_entry);
+				if (STAILQ_EMPTY(&ctx->item_listhead)) {
+					oc_pool->mask &= ~(0x1 << ctx->priority);
 				}
 
 				/* Release pool mutex */
@@ -460,20 +460,20 @@ _dispatch_workq_normal_worker_main(void *context DISPATCH_UNUSED)
 	for (;;) {
 		int idx = __builtin_ffs(os_atomic_load(&pool->mask, relaxed));
 		if (idx > 0) {
-			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);
+			dispatch_workq_context_t ctx = pool->contexts[idx - 1];
+			_dispatch_unfair_lock_lock(&ctx->lock);
+			dispatch_workq_item_t work = STAILQ_FIRST(&ctx->item_listhead);
 			if (unlikely(work == NULL)) {
 				// wasn't actually work due to racy read of mask
-				_dispatch_unfair_lock_unlock(&wq->lock);
+				_dispatch_unfair_lock_unlock(&ctx->lock);
 				continue;
 			} else {
 				// found work: remove it.
-				STAILQ_REMOVE_HEAD(&wq->item_listhead, item_entry);
-				if (STAILQ_EMPTY(&wq->item_listhead)) {
-					os_atomic_and(&pool->mask, ~(0x1 << wq->priority), relaxed);
+				STAILQ_REMOVE_HEAD(&ctx->item_listhead, item_entry);
+				if (STAILQ_EMPTY(&ctx->item_listhead)) {
+					os_atomic_and(&pool->mask, ~(0x1 << ctx->priority), relaxed);
 				}
-				_dispatch_unfair_lock_unlock(&wq->lock);
+				_dispatch_unfair_lock_unlock(&ctx->lock);
 
 				/* Execute the work item */
 				void (*func)(void *) = work->func;

src/workqueue/workqueue_internal.h

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