Merge libdispatch-913.1.4

Signed-off-by: Daniel A. Steffen <[email protected]>

Author: das

dispatch/queue.h

@@ -223,7 +223,7 @@ dispatch_sync_f(dispatch_queue_t queue,
  * @abstract
  * Constant to pass to dispatch_apply() or dispatch_apply_f() to request that
  * the system automatically use worker threads that match the configuration of
- * the current thread most closely.
+ * the current thread as closely as possible.
  *
  * @discussion
  * When submitting a block for parallel invocation, passing this constant as the

libdispatch.xcodeproj/project.pbxproj

@@ -741,10 +741,12 @@
 		96DF70BD0F38FE3C0074BD99 /* once.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; lineEnding = 0; path = once.c; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.c; };
 		B63B793F1E8F004F0060C1E1 /* dispatch_no_blocks.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = dispatch_no_blocks.c; sourceTree = "<group>"; };
 		B68330BC1EBCF6080003E71C /* dispatch_wl.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = dispatch_wl.c; sourceTree = "<group>"; };
+		B69878521F06F8790088F94F /* dispatch_signals.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = dispatch_signals.c; sourceTree = "<group>"; };
 		B6AC73FD1EB10973009FB2F2 /* perf_thread_request.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = perf_thread_request.c; sourceTree = "<group>"; };
 		B6AE9A4A1D7F53B300AC007F /* dispatch_queue_create.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = dispatch_queue_create.c; sourceTree = "<group>"; };
 		B6AE9A561D7F53C100AC007F /* perf_async_bench.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = perf_async_bench.m; sourceTree = "<group>"; };
 		B6AE9A581D7F53CB00AC007F /* perf_bench.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = perf_bench.m; sourceTree = "<group>"; };
+		B6FA01801F0AD522004479BF /* dispatch_pthread_root_queue.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = dispatch_pthread_root_queue.c; sourceTree = "<group>"; };
 		C00B0E0A1C5AEBBE000330B3 /* libdispatch_dyld_stub.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libdispatch_dyld_stub.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		C00B0E121C5AEBF7000330B3 /* libdispatch-dyld-stub.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = "libdispatch-dyld-stub.xcconfig"; sourceTree = "<group>"; };
 		C01866BD1C5973210040FC07 /* libdispatch.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libdispatch.a; sourceTree = BUILT_PRODUCTS_DIR; };
@@ -1013,6 +1015,7 @@
 				6E67D9151C1768B300FC98AC /* dispatch_pingpong.c */,
 				6E326B441C239B61002A6505 /* dispatch_priority.c */,
 				6E326AB51C225477002A6505 /* dispatch_proc.c */,
+				B6FA01801F0AD522004479BF /* dispatch_pthread_root_queue.c */,
 				6E326AB31C224870002A6505 /* dispatch_qos.c */,
 				B6AE9A4A1D7F53B300AC007F /* dispatch_queue_create.c */,
 				6E67D9111C17669C00FC98AC /* dispatch_queue_finalizer.c */,
@@ -1022,6 +1025,7 @@
 				6E326ADC1C234396002A6505 /* dispatch_readsync.c */,
 				6E8E4E6D1C1A35EE0004F5CC /* dispatch_select.c */,
 				6E8E4E9B1C1A4EF10004F5CC /* dispatch_sema.c */,
+				B69878521F06F8790088F94F /* dispatch_signals.c */,
 				6EA2CB841C005DEF0076794A /* dispatch_source.c */,
 				6E326AE01C234780002A6505 /* dispatch_starfish.c */,
 				6EE89F3D1BFAF5B000EB140D /* dispatch_state_machine.c */,

man/dispatch_apply.3

@@ -1,4 +1,4 @@
-.\" Copyright (c) 2008-2010 Apple Inc. All rights reserved.
+.\" Copyright (c) 2008-2017 Apple Inc. All rights reserved.
 .Dd May 1, 2009
 .Dt dispatch_apply 3
 .Os Darwin
@@ -20,21 +20,32 @@ The
 .Fn dispatch_apply
 function provides data-level concurrency through a "for (;;)" loop like primitive:
 .Bd -literal
-dispatch_queue_t the_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
 size_t iterations = 10;
 
 // 'idx' is zero indexed, just like:
 // for (idx = 0; idx < iterations; idx++)
 
-dispatch_apply(iterations, the_queue, ^(size_t idx) {
+dispatch_apply(iterations, DISPATCH_APPLY_AUTO, ^(size_t idx) {
 	printf("%zu\\n", idx);
 });
 .Ed
 .Pp
+Although any queue can be used, it is strongly recommended to use 
+.Vt DISPATCH_APPLY_AUTO
+as the 
+.Vt queue 
+argument to both
+.Fn dispatch_apply
+and
+.Fn dispatch_apply_f , 
+as shown in the example above, since this allows the system to automatically use worker threads
+that match the configuration of the current thread as closely as possible.
+No assumptions should be made about which global concurrent queue will be used.
+.Pp
 Like a "for (;;)" loop, the
 .Fn dispatch_apply
 function is synchronous.
-If asynchronous behavior is desired, please wrap the call to
+If asynchronous behavior is desired, wrap the call to
 .Fn dispatch_apply
 with a call to
 .Fn dispatch_async
@@ -49,7 +60,7 @@ achieved (perhaps using a power of two search):
 .Bd -literal
 #define STRIDE 3
 
-dispatch_apply(count / STRIDE, queue, ^(size_t idx) {
+dispatch_apply(count / STRIDE, DISPATCH_APPLY_AUTO, ^(size_t idx) {
 	size_t j = idx * STRIDE;
 	size_t j_stop = j + STRIDE;
 	do {
@@ -74,12 +85,21 @@ This is in contrast to asynchronous functions which must retain both the block
 and target queue for the duration of the asynchronous operation (as the calling
 function may immediately release its interest in these objects).
 .Sh FUNDAMENTALS
-Conceptually,
 .Fn dispatch_apply
-is a convenient wrapper around
+and
+.Fn dispatch_apply_f
+attempt to quickly create enough worker threads to efficiently iterate work in parallel.
+By contrast, a loop that passes work items individually to
 .Fn dispatch_async
-and a semaphore to wait for completion.
-In practice, the dispatch library optimizes this function.
+or
+.Fn dispatch_async_f
+will incur more overhead and does not express the desired parallel execution semantics to
+the system, so may not create an optimal number of worker threads for a parallel workload.
+For this reason, prefer to use 
+.Fn dispatch_apply
+or
+.Fn dispatch_apply_f
+when parallel execution is important.
 .Pp
 The
 .Fn dispatch_apply
@@ -99,5 +119,4 @@ use a for-loop around invocations of
 .Sh SEE ALSO
 .Xr dispatch 3 ,
 .Xr dispatch_async 3 ,
-.Xr dispatch_queue_create 3 ,
-.Xr dispatch_semaphore_create 3
+.Xr dispatch_queue_create 3

os/voucher_private.h

@@ -202,8 +202,23 @@ voucher_decrement_importance_count4CF(voucher_t _Nullable voucher);
  * This flag is ignored if a specific voucher object is assigned with the
  * dispatch_block_create_with_voucher* functions, and is equivalent to passing
  * the NULL voucher to these functions.
+ *
+ * @const DISPATCH_BLOCK_IF_LAST_RESET_QUEUE_QOS_OVERRIDE
+ * Flag indicating that this dispatch block object should try to reset the
+ * recorded maximum QoS of all currently enqueued items on a serial dispatch
+ * queue at the base of a queue hierarchy.
+ *
+ * This is only works if the queue becomes empty by dequeuing the block in
+ * question, and then allows that block to enqueue more work on this hierarchy
+ * without perpetuating QoS overrides resulting from items previously executed
+ * on the hierarchy.
+ *
+ * A dispatch block object created with this flag set cannot be used with
+ * dispatch_block_wait() or dispatch_block_cancel().
  */
-#define DISPATCH_BLOCK_NO_VOUCHER (0x40)
+#define DISPATCH_BLOCK_NO_VOUCHER (0x40ul)
+
+#define DISPATCH_BLOCK_IF_LAST_RESET_QUEUE_QOS_OVERRIDE (0x80ul)
 
 /*!
  * @function dispatch_block_create_with_voucher

private/private.h

@@ -43,6 +43,9 @@
 #include <sys/cdefs.h>
 #endif
 #include <pthread.h>
+#if TARGET_OS_MAC
+#include <pthread/qos.h>
+#endif
 
 #ifndef __DISPATCH_BUILDING_DISPATCH__
 #include <dispatch/dispatch.h>

private/source_private.h

@@ -102,6 +102,13 @@ DISPATCH_SOURCE_TYPE_DECL(memorystatus);
 API_AVAILABLE(macos(10.8), ios(6.0)) DISPATCH_LINUX_UNAVAILABLE()
 DISPATCH_SOURCE_TYPE_DECL(sock);
 
+/*!
+ * @const DISPATCH_SOURCE_TYPE_NW_CHANNEL
+ * @discussion A dispatch source that monitors events on a network channel.
+ */
+#define DISPATCH_SOURCE_TYPE_NW_CHANNEL (&_dispatch_source_type_nw_channel)
+API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) DISPATCH_LINUX_UNAVAILABLE()
+DISPATCH_SOURCE_TYPE_DECL(nw_channel);
 
 __END_DECLS
 
@@ -165,6 +172,15 @@ enum {
 	DISPATCH_SOCK_NOTIFY_ACK = 0x00004000,
 };
 
+/*!
+ * @enum dispatch_source_nw_channel_flags_t
+ *
+ * @constant DISPATCH_NW_CHANNEL_FLOW_ADV_UPDATE
+ * Received network channel flow advisory.
+ */
+enum {
+	DISPATCH_NW_CHANNEL_FLOW_ADV_UPDATE = 0x00000001,
+};
 
 /*!
  * @enum dispatch_source_vfs_flags_t

src/apply.c

@@ -253,12 +253,23 @@ dispatch_apply_f(size_t iterations, dispatch_queue_t dq, void *ctxt,
 	if (unlikely(iterations == 0)) {
 		return;
 	}
-	int32_t thr_cnt = (int32_t)dispatch_hw_config(active_cpus);
 	dispatch_thread_context_t dtctxt =
 			_dispatch_thread_context_find(_dispatch_apply_key);
 	size_t nested = dtctxt ? dtctxt->dtc_apply_nesting : 0;
 	dispatch_queue_t old_dq = _dispatch_queue_get_current();
 
+	if (likely(dq == DISPATCH_APPLY_AUTO)) {
+		dq = _dispatch_apply_root_queue(old_dq);
+	}
+	dispatch_qos_t qos = _dispatch_priority_qos(dq->dq_priority);
+	if (unlikely(dq->do_targetq)) {
+		// if the queue passed-in is not a root queue, use the current QoS
+		// since the caller participates in the work anyway
+		qos = _dispatch_qos_from_pp(_dispatch_get_priority());
+	}
+	int32_t thr_cnt = (int32_t)_dispatch_qos_max_parallelism(qos,
+			DISPATCH_MAX_PARALLELISM_ACTIVE);
+
 	if (likely(!nested)) {
 		nested = iterations;
 	} else {
@@ -269,9 +280,6 @@ dispatch_apply_f(size_t iterations, dispatch_queue_t dq, void *ctxt,
 	if (iterations < (size_t)thr_cnt) {
 		thr_cnt = (int32_t)iterations;
 	}
-	if (likely(dq == DISPATCH_APPLY_AUTO)) {
-		dq = _dispatch_apply_root_queue(old_dq);
-	}
 	struct dispatch_continuation_s dc = {
 		.dc_func = (void*)func,
 		.dc_ctxt = ctxt,

src/event/event_config.h

@@ -50,6 +50,25 @@
 #define DISPATCH_MACHPORT_DEBUG 0
 #endif
 
+#ifndef DISPATCH_TIMER_ASSERTIONS
+#if DISPATCH_DEBUG
+#define DISPATCH_TIMER_ASSERTIONS 1
+#else
+#define DISPATCH_TIMER_ASSERTIONS 0
+#endif
+#endif
+
+#if DISPATCH_TIMER_ASSERTIONS
+#define DISPATCH_TIMER_ASSERT(a, op, b, text) ({ \
+		typeof(a) _a = (a); \
+		if (unlikely(!(_a op (b)))) { \
+			DISPATCH_CLIENT_CRASH(_a, "Timer: " text); \
+		} \
+	})
+#else
+#define DISPATCH_TIMER_ASSERT(a, op, b, text) ((void)0)
+#endif
+
 #ifndef EV_VANISHED
 #define EV_VANISHED 0x0200
 #endif
@@ -105,6 +124,11 @@
 #	ifndef VQ_DESIRED_DISK
 #	undef HAVE_DECL_VQ_DESIRED_DISK
 #	endif // VQ_DESIRED_DISK
+
+#	if !defined(EVFILT_NW_CHANNEL) && defined(__APPLE__)
+#	define EVFILT_NW_CHANNEL       (-16)
+#	define NOTE_FLOW_ADV_UPDATE    	0x1
+#	endif
 #else // DISPATCH_EVENT_BACKEND_KEVENT
 #	define EV_ADD					0x0001
 #	define EV_DELETE				0x0002

src/event/event_kevent.c

@@ -671,8 +671,9 @@ _dispatch_kq_drain(dispatch_wlh_t wlh, dispatch_kevent_t ke, int n,
 		r = 0;
 	} else if (flags & KEVENT_FLAG_ERROR_EVENTS) {
 		for (i = 0, r = 0; i < n; i++) {
-			if ((ke_out[i].flags & EV_ERROR) && (r = (int)ke_out[i].data)) {
+			if ((ke_out[i].flags & EV_ERROR) && ke_out[i].data) {
 				_dispatch_kevent_drain(&ke_out[i]);
+				r = (int)ke_out[i].data;
 			}
 		}
 	} else {
@@ -1407,6 +1408,17 @@ const dispatch_source_type_s _dispatch_source_type_sock = {
 };
 #endif // EVFILT_SOCK
 
+#ifdef EVFILT_NW_CHANNEL
+const dispatch_source_type_s _dispatch_source_type_nw_channel = {
+	.dst_kind       = "nw_channel",
+	.dst_filter     = EVFILT_NW_CHANNEL,
+	.dst_flags      = DISPATCH_EV_DIRECT|EV_CLEAR|EV_VANISHED,
+	.dst_mask       = NOTE_FLOW_ADV_UPDATE,
+	.dst_size       = sizeof(struct dispatch_source_refs_s),
+	.dst_create     = _dispatch_unote_create_with_fd,
+	.dst_merge_evt  = _dispatch_source_merge_evt,
+};
+#endif // EVFILT_NW_CHANNEL
 
 #if DISPATCH_USE_MEMORYSTATUS
 
@@ -1609,9 +1621,9 @@ _dispatch_mach_notify_source_invoke(mach_msg_header_t *hdr)
 	if (!tlr) {
 		DISPATCH_INTERNAL_CRASH(0, "message received without expected trailer");
 	}
-	if (tlr->msgh_audit.val[DISPATCH_MACH_AUDIT_TOKEN_PID] != 0) {
-		(void)dispatch_assume_zero(
-				tlr->msgh_audit.val[DISPATCH_MACH_AUDIT_TOKEN_PID]);
+	if (hdr->msgh_id <= MACH_NOTIFY_LAST
+			&& dispatch_assume_zero(tlr->msgh_audit.val[
+			DISPATCH_MACH_AUDIT_TOKEN_PID])) {
 		mach_msg_destroy(hdr);
 		return;
 	}

src/init.c

@@ -897,6 +897,7 @@ void
 _dispatch_temporary_resource_shortage(void)
 {
 	sleep(1);
+	asm("");  // prevent tailcall
 }
 
 void *

src/inline_internal.h

@@ -1740,7 +1740,7 @@ static inline dispatch_priority_t
 _dispatch_root_queue_identity_assume(dispatch_queue_t assumed_rq)
 {
 	dispatch_priority_t old_dbp = _dispatch_get_basepri();
-	dispatch_assert(dx_type(assumed_rq) == DISPATCH_QUEUE_GLOBAL_ROOT_TYPE);
+	dispatch_assert(dx_hastypeflag(assumed_rq, QUEUE_ROOT));
 	_dispatch_reset_basepri(assumed_rq->dq_priority);
 	_dispatch_queue_set_current(assumed_rq);
 	return old_dbp;
@@ -2108,11 +2108,25 @@ _dispatch_queue_priority_inherit_from_target(dispatch_queue_t dq,
 
 	if ((!_dispatch_priority_qos(pri) || (pri & inherited_flag)) &&
 			(tpri & rootqueue_flag)) {
+		if (_dispatch_priority_override_qos(pri) == DISPATCH_QOS_SATURATED) {
+			pri &= DISPATCH_PRIORITY_OVERRIDE_MASK;
+		} else {
+			pri = 0;
+		}
 		if (tpri & defaultqueue_flag) {
-			dq->dq_priority = 0;
+			// <rdar://problem/32921639> base queues need to know they target
+			// the default root queue so that _dispatch_queue_override_qos()
+			// in _dispatch_queue_class_wakeup() can fallback to QOS_DEFAULT
+			// if no other priority was provided.
+			pri |= defaultqueue_flag;
 		} else {
-			dq->dq_priority = (tpri & ~rootqueue_flag) | inherited_flag;
+			pri |= (tpri & ~rootqueue_flag) | inherited_flag;
 		}
+		dq->dq_priority = pri;
+	} else if (pri & defaultqueue_flag) {
+		// the DEFAULTQUEUE flag is only set on queues due to the code above,
+		// and must never be kept if we don't target a global root queue.
+		dq->dq_priority = (pri & ~defaultqueue_flag);
 	}
 #else
 	(void)dq; (void)tq;
@@ -2272,7 +2286,9 @@ static inline dispatch_qos_t
 _dispatch_queue_override_qos(dispatch_queue_class_t dqu, dispatch_qos_t qos)
 {
 	if (dqu._oq->oq_priority & DISPATCH_PRIORITY_FLAG_DEFAULTQUEUE) {
-		return qos;
+		// queues targeting the default root queue use any asynchronous
+		// workitem priority available and fallback to QOS_DEFAULT otherwise.
+		return qos ? qos : DISPATCH_QOS_DEFAULT;
 	}
 	// for asynchronous workitems, queue priority is the floor for overrides
 	return MAX(qos, _dispatch_priority_qos(dqu._oq->oq_priority));
@@ -2338,14 +2354,20 @@ _dispatch_block_has_private_data(const dispatch_block_t block)
 }
 
 DISPATCH_ALWAYS_INLINE DISPATCH_WARN_RESULT
-static inline bool
-_dispatch_block_invoke_should_set_priority(dispatch_block_flags_t flags)
-{
-	if (flags & DISPATCH_BLOCK_HAS_PRIORITY) {
-		return (flags & DISPATCH_BLOCK_ENFORCE_QOS_CLASS) ||
-				!(flags & DISPATCH_BLOCK_INHERIT_QOS_CLASS);
-	}
-	return false;
+static inline pthread_priority_t
+_dispatch_block_invoke_should_set_priority(dispatch_block_flags_t flags,
+        pthread_priority_t new_pri)
+{
+	pthread_priority_t old_pri, p = 0;  // 0 means do not change priority.
+	if ((flags & DISPATCH_BLOCK_HAS_PRIORITY)
+			&& ((flags & DISPATCH_BLOCK_ENFORCE_QOS_CLASS) ||
+			!(flags & DISPATCH_BLOCK_INHERIT_QOS_CLASS))) {
+		old_pri = _dispatch_get_priority();
+		new_pri &= ~_PTHREAD_PRIORITY_FLAGS_MASK;
+		p = old_pri & ~_PTHREAD_PRIORITY_FLAGS_MASK;
+		if (!p || p >= new_pri) p = 0;
+	}
+	return p;
 }
 
 DISPATCH_ALWAYS_INLINE