adjust names of a few statics

Author: dgrove-oss

src/workqueue/workqueue.c

@@ -63,13 +63,13 @@
 static volatile int32_t _dispatch_workq_runnable_workers;
 
 /* The desired minimum number of runnable worker threads */
-static int32_t _dispatch_workq_target_runnable_workers;
+static int32_t _dispatch_workq_min_runnable_workers;
 
 /* The desired maximum number of runnable worker threads */
-static int32_t _dispatch_workq_target_max_runnable_workers;
+static int32_t _dispatch_workq_max_runnable_workers;
 
 /* Limit on the total number of worker threads that can be created. */
-static int32_t _dispatch_workq_max_total_workers;
+static int32_t _dispatch_workq_max_spawned_workers;
 
 #if DISPATCH_ENABLE_PWQ_KEXT
 /* Are we using user-level or kext based management? */
@@ -124,7 +124,7 @@ void _dispatch_workq_worker_register_kext(void);
 void _dispatch_workq_worker_unregister_kext(void);
 void _dispatch_workq_work_added_kext(void);
 void _dispatch_workq_worker_wait_kext(void);
-void* dispatch_workq_thread_monitor_main_kext(void *context DISPATCH_UNUSED);
+void* _dispatch_workq_thread_monitor_main_kext(void *context DISPATCH_UNUSED);
 #endif // DISPATCH_ENABLE_PWQ_KEXT
 
 #pragma mark Workqueue internal data structures and functions
@@ -258,14 +258,14 @@ _dispatch_workq_init_once(void *context DISPATCH_UNUSED)
 			high_target = MIN(high_target, max);
 		}
 	}
-	_dispatch_workq_target_runnable_workers = low_target;
-	_dispatch_workq_target_max_runnable_workers = high_target;
-	_dispatch_workq_max_total_workers = max;
+	_dispatch_workq_min_runnable_workers = low_target;
+	_dispatch_workq_max_runnable_workers = high_target;
+	_dispatch_workq_max_spawned_workers = max;
 
 	// Must come after _dispatch_workqueue_management_init() sets threadpool_verbose
 	_dispatch_debug("workq: normal pool targets: %d...%d with max of %d",
-			_dispatch_workq_target_runnable_workers, _dispatch_workq_target_max_runnable_workers,
-			_dispatch_workq_max_total_workers);
+			_dispatch_workq_min_runnable_workers, _dispatch_workq_max_runnable_workers,
+			_dispatch_workq_max_spawned_workers);
 
 	// Now that we have set threadpool parameters, initialize the management subsystem
 	_dispatch_workq_management_init();
@@ -284,7 +284,7 @@ _dispatch_workq_init_once(void *context DISPATCH_UNUSED)
 			WORKQ_NUM_PRIORITIES, false);
 
 	// create initial set of normal workers
-	for (int i=0; i<_dispatch_workq_target_runnable_workers; i++) {
+	for (int i=0; i<_dispatch_workq_min_runnable_workers; i++) {
 		_dispatch_workq_spawn_thread(_dispatch_workq_normal_worker_main);
 	}
 }
@@ -335,7 +335,7 @@ dispatch_workq_additem_np(dispatch_workqueue_t workq,
 		STAILQ_INSERT_TAIL(&workq->item_listhead, wi, item_entry);
 		_dispatch_unfair_lock_unlock(&workq->lock);
 
-		if (unlikely(_dispatch_workq_runnable_workers < _dispatch_workq_target_max_runnable_workers)) {
+		if (unlikely(_dispatch_workq_runnable_workers < _dispatch_workq_max_runnable_workers)) {
 			_dispatch_workq_work_added();
 		}
 	}
@@ -358,7 +358,7 @@ _dispatch_workq_add_control_item(void *op_code)
 	STAILQ_INSERT_TAIL(&workq->item_listhead, wi, item_entry);
 	_dispatch_unfair_lock_unlock(&workq->lock);
 
-	if (unlikely(_dispatch_workq_runnable_workers < _dispatch_workq_target_max_runnable_workers)) {
+	if (unlikely(_dispatch_workq_runnable_workers < _dispatch_workq_max_runnable_workers)) {
 		_dispatch_workq_work_added();
 	}
 }
@@ -558,7 +558,7 @@ _dispatch_workq_management_init(void)
 	_dispatch_workq_kext_active = _dispatch_workqueue_management_init_kext();
 
 	if (_dispatch_workq_kext_active) {
-		_dispatch_spawn_thread(dispatch_thread_monitor_main_kext);
+		_dispatch_spawn_thread(_dispatch_thread_monitor_main_kext);
 		return;
 	}
 #endif
@@ -573,7 +573,7 @@ _dispatch_workq_management_init(void)
 	(void)dispatch_assume_zero(r);
 
 	_dispatch_workq_manager.registered_workers =
-			_dispatch_calloc(_dispatch_workq_max_total_workers, sizeof(pid_t));
+			_dispatch_calloc(_dispatch_workq_max_spawned_workers, sizeof(pid_t));
 
 	// spawn a thread to periodically estimate the number
 	// of runnable workers and add/subtract to maintain target
@@ -593,7 +593,7 @@ _dispatch_workq_worker_register(void)
 	int tid = syscall(SYS_gettid);
 	int r = pthread_mutex_lock(&_dispatch_workq_manager.registered_worker_mutex);
 	(void)dispatch_assume_zero(r);
-	if (_dispatch_workq_manager.num_registered_workers < _dispatch_workq_max_total_workers-1) {
+	if (_dispatch_workq_manager.num_registered_workers < _dispatch_workq_max_spawned_workers-1) {
 		int worker_id = _dispatch_workq_manager.num_registered_workers++;
 		_dispatch_workq_manager.registered_workers[worker_id] = tid;
 		rc = 0;
@@ -640,7 +640,7 @@ _dispatch_workq_work_added(void)
 		return;
 	}
 #endif
-	if ((_dispatch_workq_runnable_workers < _dispatch_workq_target_max_runnable_workers)
+	if ((_dispatch_workq_runnable_workers < _dispatch_workq_max_runnable_workers)
 			&& (_dispatch_workq_manager.num_spare_workers > 0)) {
 		int r = pthread_mutex_lock(&_dispatch_workq_manager.spare_worker_mutex);
 		(void)dispatch_assume_zero(r);
@@ -794,10 +794,10 @@ _dispatch_workq_thread_monitor_main(void *context DISPATCH_UNUSED)
 
 		_dispatch_debug("workq: %d runnable of %d total workers (target runnable: %d..%d)",
 				_dispatch_workq_runnable_workers, _dispatch_workq_manager.num_registered_workers,
-				_dispatch_workq_target_runnable_workers, _dispatch_workq_target_max_runnable_workers);
+				_dispatch_workq_min_runnable_workers, _dispatch_workq_max_runnable_workers);
 
 		// Not enough workers running and there appears to be work in queues.
-		if ((_dispatch_workq_runnable_workers < _dispatch_workq_target_runnable_workers) &&
+		if ((_dispatch_workq_runnable_workers < _dispatch_workq_min_runnable_workers) &&
 			(os_atomic_load(&_dispatch_workq_normal_pool.mask, relaxed) != 0)) {
 			r = pthread_mutex_lock(&_dispatch_workq_manager.spare_worker_mutex);
 			(void)dispatch_assume_zero(r);
@@ -814,8 +814,8 @@ _dispatch_workq_thread_monitor_main(void *context DISPATCH_UNUSED)
 		}
 
 		// Too many runnable workers
-		if (_dispatch_workq_runnable_workers > _dispatch_workq_target_max_runnable_workers) {
-			int over = _dispatch_workq_runnable_workers - _dispatch_workq_target_max_runnable_workers;
+		if (_dispatch_workq_runnable_workers > _dispatch_workq_max_runnable_workers) {
+			int over = _dispatch_workq_runnable_workers - _dispatch_workq_max_runnable_workers;
 			int pendingWaits = os_atomic_load(&_dispatch_workq_manager.num_pending_waits, relaxed);
 			if (pendingWaits < over) {
 				os_atomic_inc(&_dispatch_workq_manager.num_pending_waits, relaxed);