Updates for 1121 release for Windows

Make the 1121 release build on Windows.  This is sufficient for getting
a basic Hello World dispatch program to run under swift again.

Author: compnerd

src/event/event_windows.c

@@ -21,59 +21,197 @@
 #include "internal.h"
 #if DISPATCH_EVENT_BACKEND_WINDOWS
 
+static HANDLE hPort = NULL;
+enum _dispatch_iocp_completion_key
+{
+	DISPATCH_PORT_POKE = 0,
+	DISPATCH_PORT_TIMER_CLOCK_UPTIME,
+};
+
+typedef struct _dispatch_windows_timeout_s {
+	PTP_TIMER pTimer;
+	enum _dispatch_iocp_completion_key ullIdent;
+	BOOL bArmed;
+} *dispatch_windows_timeout_t;
+
+#define DISPATCH_WINDOWS_TIMEOUT_INITIALIZER(clock)                            \
+	[DISPATCH_CLOCK_##clock] = {                                           \
+		.pTimer = NULL,                                                \
+		.ullIdent = DISPATCH_PORT_TIMER_CLOCK_##clock,                 \
+		.bArmed = FALSE,                                               \
+	}
+static struct _dispatch_windows_timeout_s _dispatch_windows_timeout[] = {
+//	DISPATCH_WINDOWS_TIMEOUT_INITIALIZER(WALL),
+	DISPATCH_WINDOWS_TIMEOUT_INITIALIZER(UPTIME),
+//	DISPATCH_WINDOWS_TIMEOUT_INITIALIZER(MONOTONIC),
+};
+
+#pragma mark Helpers
+
 #pragma mark dispatch_unote_t
 
 bool
-_dispatch_unote_register(dispatch_unote_t du DISPATCH_UNUSED,
-		dispatch_wlh_t wlh DISPATCH_UNUSED,
-		dispatch_priority_t pri DISPATCH_UNUSED)
+_dispatch_unote_register_muxed(dispatch_unote_t du DISPATCH_UNUSED)
 {
 	WIN_PORT_ERROR();
 	return false;
 }
 
 void
-_dispatch_unote_resume(dispatch_unote_t du DISPATCH_UNUSED)
+_dispatch_unote_resume_muxed(dispatch_unote_t du DISPATCH_UNUSED)
 {
 	WIN_PORT_ERROR();
 }
 
 bool
-_dispatch_unote_unregister(dispatch_unote_t du DISPATCH_UNUSED,
-		uint32_t flags DISPATCH_UNUSED)
+_dispatch_unote_unregister_muxed(dispatch_unote_t du DISPATCH_UNUSED)
 {
 	WIN_PORT_ERROR();
 	return false;
 }
 
 #pragma mark timers
 
+static void CALLBACK
+_dispatch_timer_callback(PTP_CALLBACK_INSTANCE Instance, PVOID Context,
+	PTP_TIMER Timer)
+{
+	BOOL bSuccess;
+
+	bSuccess = PostQueuedCompletionStatus(hPort, 0, (ULONG_PTR)Context, NULL);
+	if (bSuccess == FALSE)
+		DISPATCH_INTERNAL_CRASH(GetLastError(), "PostQueuedCompletionStatus");
+}
+
 void
-_dispatch_event_loop_timer_arm(uint32_t tidx DISPATCH_UNUSED,
-		dispatch_timer_delay_s range DISPATCH_UNUSED,
+_dispatch_event_loop_timer_arm(dispatch_timer_heap_t dth DISPATCH_UNUSED,
+		uint32_t tidx, dispatch_timer_delay_s range,
 		dispatch_clock_now_cache_t nows DISPATCH_UNUSED)
 {
-	WIN_PORT_ERROR();
+	dispatch_windows_timeout_t timer;
+	FILETIME ftDueTime;
+	LARGE_INTEGER ulTime;
+
+	switch (DISPATCH_TIMER_CLOCK(tidx)) {
+	case DISPATCH_CLOCK_UPTIME:
+		timer = &_dispatch_windows_timeout[DISPATCH_CLOCK_UPTIME];
+		ulTime.QuadPart = -((range.delay + 99) / 100);
+		break;
+	default:
+		WIN_PORT_ERROR();
+		__assume(0);
+	}
+
+	if (timer->pTimer == NULL)
+	{
+		timer->pTimer = CreateThreadpoolTimer(_dispatch_timer_callback,
+				(LPVOID)timer->ullIdent, NULL);
+		if (timer->pTimer == NULL)
+			DISPATCH_INTERNAL_CRASH(GetLastError(), "CreateThreadpoolTimer");
+	}
+
+	ftDueTime.dwHighDateTime = ulTime.HighPart;
+	ftDueTime.dwLowDateTime = ulTime.LowPart;
+
+	SetThreadpoolTimer(timer->pTimer, &ftDueTime, /*msPeriod=*/0,
+		/*msWindowLength=*/0);
+	timer->bArmed = TRUE;
 }
 
 void
-_dispatch_event_loop_timer_delete(uint32_t tidx DISPATCH_UNUSED)
+_dispatch_event_loop_timer_delete(dispatch_timer_heap_t dth DISPATCH_UNUSED,
+		uint32_t tidx)
 {
-	WIN_PORT_ERROR();
+	dispatch_windows_timeout_t timer;
+
+	switch (DISPATCH_TIMER_CLOCK(tidx)) {
+	case DISPATCH_CLOCK_UPTIME:
+		timer = &_dispatch_windows_timeout[DISPATCH_PORT_TIMER_CLOCK_UPTIME];
+		break;
+	default:
+		WIN_PORT_ERROR();
+		__assume(0);
+	}
+
+	SetThreadpoolTimer(timer->pTimer, NULL, /*msPeriod=*/0,
+		/*msWindowLength=*/0);
+	timer->bArmed = FALSE;
 }
 
 #pragma mark dispatch_loop
 
+static void
+_dispatch_port_init(void *context DISPATCH_UNUSED)
+{
+	hPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);
+	if (hPort == NULL) {
+		DISPATCH_INTERNAL_CRASH(GetLastError(), "CreateIoCompletionPort");
+	}
+
+#if DISPATCH_USE_MGR_THREAD
+	_dispatch_trace_item_push(_dispatch_mgr_q.do_targetq, &_dispatch_mgr_q);
+	dx_push(_dispatch_mgr_q.do_targetq, &_dispatch_mgr_q, 0);
+#endif
+}
+
 void
 _dispatch_event_loop_poke(dispatch_wlh_t wlh DISPATCH_UNUSED,
 		uint64_t dq_state DISPATCH_UNUSED, uint32_t flags DISPATCH_UNUSED)
 {
-	WIN_PORT_ERROR();
+	static dispatch_once_t _dispatch_port_pred;
+	dispatch_once_f(&_dispatch_port_pred, NULL, _dispatch_port_init);
+	BOOL bResult = PostQueuedCompletionStatus(hPort, 0, DISPATCH_PORT_POKE,
+		NULL);
+	(void)dispatch_assume(bResult);
+}
+
+static void
+_dispatch_event_merge_timer(dispatch_clock_t clock)
+{
+	dispatch_timer_heap_t dth = _dispatch_timers_heap;
+	uint32_t tidx = DISPATCH_TIMER_INDEX(clock, 0);
+
+	_dispatch_windows_timeout[clock].bArmed = FALSE;
+
+	_dispatch_timers_heap_dirty(dth, tidx);
+	dth[tidx].dth_needs_program = true;
+	dth[tidx].dth_armed = false;
 }
 
 DISPATCH_NOINLINE
 void
-_dispatch_event_loop_drain(uint32_t flags DISPATCH_UNUSED)
+_dispatch_event_loop_drain(uint32_t flags)
+{
+	DWORD dwNumberOfBytesTransferred;
+	ULONG_PTR ulCompletionKey;
+	LPOVERLAPPED pOV;
+
+	pOV = (LPOVERLAPPED)&pOV;
+	BOOL bResult = GetQueuedCompletionStatus(hPort,
+		&dwNumberOfBytesTransferred, &ulCompletionKey, &pOV,
+		(flags & KEVENT_FLAG_IMMEDIATE) ? 0 : INFINITE);
+
+	while (bResult)
+	{
+		switch (ulCompletionKey)
+		{
+		case DISPATCH_PORT_POKE:
+			break;
+		case DISPATCH_PORT_TIMER_CLOCK_UPTIME:
+                        _dispatch_event_merge_timer(DISPATCH_CLOCK_UPTIME);
+			break;
+		}
+
+		bResult = GetQueuedCompletionStatus(hPort,
+			&dwNumberOfBytesTransferred, &ulCompletionKey, &pOV, 0);
+	}
+
+	if (bResult == FALSE && pOV != NULL)
+		DISPATCH_INTERNAL_CRASH(GetLastError(), "GetQueuedCompletionStatus");
+}
+
+void
+_dispatch_event_loop_cancel_waiter(dispatch_sync_context_t dsc DISPATCH_UNUSED)
 {
 	WIN_PORT_ERROR();
 }
@@ -109,9 +247,9 @@ _dispatch_event_loop_assert_not_owned(dispatch_wlh_t wlh)
 #endif
 
 void
-_dispatch_event_loop_leave_immediate(dispatch_wlh_t wlh, uint64_t dq_state)
+_dispatch_event_loop_leave_immediate(uint64_t dq_state)
 {
-	(void)wlh; (void)dq_state;
+	(void)dq_state;
 }
 
 #endif // DISPATCH_EVENT_BACKEND_WINDOWS

src/event/workqueue.c

@@ -97,7 +97,6 @@ _dispatch_workq_worker_register(dispatch_queue_global_t root_q)
 	_dispatch_unfair_lock_unlock(&mon->registered_tid_lock);
 #else
 	(void)root_q;
-	(void)cls;
 #endif // HAVE_DISPATCH_WORKQ_MONITORING
 }
 
@@ -124,7 +123,6 @@ _dispatch_workq_worker_unregister(dispatch_queue_global_t root_q)
 	_dispatch_unfair_lock_unlock(&mon->registered_tid_lock);
 #else
 	(void)root_q;
-	(void)cls;
 #endif // HAVE_DISPATCH_WORKQ_MONITORING
 }
 

src/init.c

@@ -739,7 +739,7 @@ DISPATCH_VTABLE_SUBCLASS_INSTANCE(queue_main, lane,
 	.dq_push        = _dispatch_main_queue_push,
 );
 
-#if DISPATCH_COCOA_COMPAT
+#if DISPATCH_COCOA_COMPAT || defined(_WIN32)
 DISPATCH_VTABLE_SUBCLASS_INSTANCE(queue_runloop, lane,
 	.do_type        = DISPATCH_QUEUE_RUNLOOP_TYPE,
 	.do_dispose     = _dispatch_runloop_queue_dispose,

src/inline_internal.h

@@ -1294,7 +1294,7 @@ _dispatch_queue_drain_try_lock_wlh(dispatch_queue_t dq, uint64_t *dq_state)
 	if (unlikely(!_dq_state_is_base_wlh(old_state) ||
 			!_dq_state_is_enqueued_on_target(old_state) ||
 			_dq_state_is_enqueued_on_manager(old_state))) {
-#if !__LP64__
+#if DISPATCH_SIZEOF_PTR == 4
 		old_state >>= 32;
 #endif
 		DISPATCH_INTERNAL_CRASH(old_state, "Invalid wlh state");

src/io.c

@@ -152,7 +152,7 @@ enum {
 #endif // DISPATCH_IO_DEBUG
 
 #define _dispatch_fd_debug(msg, fd, ...) \
-		_dispatch_io_log("fd[0x%x]: " msg, fd, ##__VA_ARGS__)
+		_dispatch_io_log("fd[0x%" PRIx64 "]: " msg, fd, ##__VA_ARGS__)
 #define _dispatch_op_debug(msg, op, ...) \
 		_dispatch_io_log("op[%p]: " msg, op, ##__VA_ARGS__)
 #define _dispatch_channel_debug(msg, channel, ...) \
@@ -1385,7 +1385,7 @@ _dispatch_fd_entry_create_with_fd(dispatch_fd_t fd, uintptr_t hash)
 	// On fds lock queue
 	dispatch_fd_entry_t fd_entry = _dispatch_fd_entry_create(
 			_dispatch_io_fds_lockq);
-	_dispatch_fd_entry_debug("create: fd %d", fd_entry, fd);
+	_dispatch_fd_entry_debug("create: fd %" PRId64, fd_entry, fd);
 	fd_entry->fd = fd;
 	LIST_INSERT_HEAD(&_dispatch_io_fds[hash], fd_entry, fd_list);
 	fd_entry->barrier_queue = dispatch_queue_create(
@@ -1399,11 +1399,11 @@ _dispatch_fd_entry_create_with_fd(dispatch_fd_t fd, uintptr_t hash)
 			int result = ioctlsocket((SOCKET)fd, (long)FIONBIO, &value);
 			(void)dispatch_assume_zero(result);
 			_dispatch_stream_init(fd_entry,
-				_dispatch_get_root_queue(DISPATCH_QOS_DEFAULT, false));
+				_dispatch_get_default_queue(false));
 		} else {
 			dispatch_suspend(fd_entry->barrier_queue);
-			dispatch_once_f(&_dispatch_io_devs_lockq_pred, NULL,
-					_dispatch_io_devs_lockq_init);
+			dispatch_once_f(&_dispatch_io_init_pred, NULL,
+					_dispatch_io_queues_init);
 			dispatch_async(_dispatch_io_devs_lockq, ^{
 				_dispatch_disk_init(fd_entry, 0);
 				dispatch_resume(fd_entry->barrier_queue);

src/object.c

@@ -203,7 +203,9 @@ _dispatch_xref_dispose(dispatch_object_t dou)
 		break;
 #endif
 	case DISPATCH_QUEUE_RUNLOOP_TYPE:
+#if DISPATCH_COCOA_COMPAT
 		_dispatch_runloop_queue_xref_dispose(dou._dl);
+#endif
 		break;
 	}
 	return _dispatch_release_tailcall(dou._os_obj);