Nikita Tsukanov
3 months ago
committed by
GitHub
GitHub
6 changed files with 337 additions and 260 deletions
@ -0,0 +1,19 @@ |
|||||
|
using System; |
||||
|
using Avalonia.X11.Dispatching; |
||||
|
|
||||
|
namespace Avalonia.Wayland; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// GLib (GMainLoop) based UI-thread dispatcher for the Wayland backend, enabled via
|
||||
|
/// <see cref="WaylandPlatformOptions.UseGLibMainLoop"/>. It lets Avalonia share a GLib main loop with GLib/GTK
|
||||
|
/// based libraries on the UI thread. Unlike X11 it attaches no platform event source of its own: the Wayland
|
||||
|
/// connection is owned and pumped by the worker thread, which posts input/events back via the dispatcher, so the
|
||||
|
/// base class' signaling/timer/background machinery is all the UI thread needs.
|
||||
|
/// </summary>
|
||||
|
internal sealed class WaylandGlibDispatcher : GlibDispatcherImplBase |
||||
|
{ |
||||
|
public WaylandGlibDispatcher(Action<Exception>? externalExceptionLogger) |
||||
|
: base(externalExceptionLogger) |
||||
|
{ |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,289 @@ |
|||||
|
using System; |
||||
|
using System.Collections.Generic; |
||||
|
using System.Diagnostics; |
||||
|
using System.Linq; |
||||
|
using System.Runtime.ExceptionServices; |
||||
|
using System.Threading; |
||||
|
using Avalonia.Logging; |
||||
|
using Avalonia.Threading; |
||||
|
using static Avalonia.X11.Interop.Glib; |
||||
|
namespace Avalonia.X11.Dispatching; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Platform-agnostic GLib (GMainLoop/GSource) based dispatcher implementation. It maps Avalonia's dispatcher model
|
||||
|
/// onto GLib so Avalonia code can share a GLib main loop with GLib/GTK based libraries on the UI thread.
|
||||
|
/// It owns no platform event source by itself; backends derive from it to attach their own (e.g. the X11 socket).
|
||||
|
/// </summary>
|
||||
|
internal abstract class GlibDispatcherImplBase : |
||||
|
IDispatcherImplWithExplicitBackgroundProcessing, |
||||
|
IControlledDispatcherImpl |
||||
|
{ |
||||
|
/* |
||||
|
GLib priorities and Avalonia priorities are a bit different. Avalonia follows the WPF model when there |
||||
|
are "background" and "foreground" priority groups. Foreground jobs are executed before any user input processing, |
||||
|
background jobs are executed strictly after user input processing. |
||||
|
|
||||
|
GLib has numeric priorities that are used in the following way: |
||||
|
-100 G_PRIORITY_HIGH - "high" priority sources, not really used by GLib/GTK |
||||
|
0 G_PRIORITY_DEFAULT - polling X11 events (GTK) and default value for g_timeout_add |
||||
|
100 G_PRIORITY_HIGH_IDLE without a clear definition, used as an anchor value of sorts |
||||
|
110 Resize/layout operations (GTK) |
||||
|
120 Render operations (GTK) |
||||
|
200 G_PRIORITY_DEFAULT_IDLE - "idle" priority sources |
||||
|
|
||||
|
So, unlike Avalonia, GTK puts way higher priority on input processing, then does resize/layout/render |
||||
|
|
||||
|
So, to map our model to GLib we do the following: |
||||
|
- foreground jobs (including grouped user events) are executed with (-1) priority (_before_ any normal GLib jobs) |
||||
|
- the platform event source is polled with G_PRIORITY_DEFAULT, all events are read until the socket is empty, |
||||
|
we also group input events at that stage (this matches our epoll-based dispatcher) |
||||
|
- background jobs are executed with G_PRIORITY_DEFAULT_IDLE, so they would have lower priority than GTK |
||||
|
foreground jobs |
||||
|
|
||||
|
Unfortunately we can't detect if there are pending _non-idle_ GLib jobs using g_main_context_pending, since |
||||
|
- g_main_context_pending doesn't accept max_priority argument |
||||
|
- even if it did, that would still involve a syscall to the kernel to poll for fds anyway |
||||
|
|
||||
|
So we just report that we don't support pending input query and let the dispatcher to |
||||
|
call RequestBackgroundProcessing every time, which results in g_idle_add call for every background job. |
||||
|
Background jobs are expected to be relatively expensive to execute since on Windows |
||||
|
MsgWaitForMultipleObjectsEx results isn't really free too. |
||||
|
|
||||
|
For signaling (aka waking up dispatcher for processing _high_ priority jobs we are using |
||||
|
g_idle_add_full with (-1) priority. While the naming suggests that it would enqueue an idle job, |
||||
|
it actually adds an always-triggered source that would be called before other sources with lower priority. |
||||
|
|
||||
|
For timers we are using a simple g_timeout_add_full and discard the previous one when dispatcher requests |
||||
|
an update |
||||
|
|
||||
|
Since GLib dispatches event sources in batches, we force-check for "signaled" flag to run high-prio jobs |
||||
|
whenever we get control back from GLib. We can still occasionally get GTK code to run before high-prio |
||||
|
Avalonia-jobs, but that should be fine since the point is to keep Avalonia-based jobs ordered properly |
||||
|
and to not have our low-priority jobs to prevent GLib-based code from running its own "foreground" jobs |
||||
|
|
||||
|
Another implementation note here is that GLib (just as any other C library) is NOT aware of C# exceptions, |
||||
|
so we are NOT allowed to have exceptions to escape native->managed call boundary. So we have exception handlers |
||||
|
that try to propagate those to the nearest run loop frame that was initiated by Avalonia. |
||||
|
|
||||
|
If there is no such frame, we have no choice but to log/swallow those |
||||
|
*/ |
||||
|
|
||||
|
// Note that we can't use g_main_context_is_owner outside a run loop, since context doesn't really have an
|
||||
|
// inherent owner when run loop is not running and the context isn't explicitly "locked", so we just assume that
|
||||
|
// the app author is initializing Avalonia on the intended UI thread and won't migrate the default run loop
|
||||
|
// to a different thread
|
||||
|
private readonly Thread _mainThread = Thread.CurrentThread; |
||||
|
|
||||
|
private readonly Action<Exception>? _externalExceptionLogger; |
||||
|
private bool _signaled; |
||||
|
private bool _signaledSourceAdded; |
||||
|
private readonly object _signalLock = new(); |
||||
|
private readonly Stack<ManagedLoopFrame> _runLoopStack = new(); |
||||
|
|
||||
|
private readonly Stopwatch _stopwatch = Stopwatch.StartNew(); |
||||
|
private uint? _glibTimerSourceTag; |
||||
|
|
||||
|
protected GlibDispatcherImplBase(Action<Exception>? externalExceptionLogger) |
||||
|
{ |
||||
|
_externalExceptionLogger = externalExceptionLogger; |
||||
|
} |
||||
|
|
||||
|
public bool CurrentThreadIsLoopThread => _mainThread == Thread.CurrentThread; |
||||
|
|
||||
|
public event Action? Signaled; |
||||
|
public void Signal() |
||||
|
{ |
||||
|
lock (_signalLock) |
||||
|
{ |
||||
|
if(_signaled) |
||||
|
return; |
||||
|
_signaled = true; |
||||
|
if(_signaledSourceAdded) |
||||
|
return; |
||||
|
_signaledSourceAdded = true; |
||||
|
} |
||||
|
g_idle_add_full(G_PRIORITY_DEFAULT - 1, SignalSourceCallback); |
||||
|
} |
||||
|
|
||||
|
protected void CheckSignaled() |
||||
|
{ |
||||
|
lock (_signalLock) |
||||
|
{ |
||||
|
if (!_signaled) |
||||
|
return; |
||||
|
_signaled = false; |
||||
|
} |
||||
|
|
||||
|
try |
||||
|
{ |
||||
|
Signaled?.Invoke(); |
||||
|
} |
||||
|
catch (Exception e) |
||||
|
{ |
||||
|
HandleException(e); |
||||
|
} |
||||
|
Flush(); |
||||
|
} |
||||
|
|
||||
|
private bool SignalSourceCallback() |
||||
|
{ |
||||
|
lock (_signalLock) |
||||
|
{ |
||||
|
_signaledSourceAdded = false; |
||||
|
} |
||||
|
CheckSignaled(); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
public event Action? Timer; |
||||
|
public long Now => _stopwatch.ElapsedMilliseconds; |
||||
|
|
||||
|
public void UpdateTimer(long? dueTimeInMs) |
||||
|
{ |
||||
|
if (_glibTimerSourceTag.HasValue) |
||||
|
{ |
||||
|
g_source_remove(_glibTimerSourceTag.Value); |
||||
|
_glibTimerSourceTag = null; |
||||
|
} |
||||
|
|
||||
|
if (dueTimeInMs == null) |
||||
|
return; |
||||
|
|
||||
|
var interval = (uint)Math.Max(0, (int)Math.Min(int.MaxValue, dueTimeInMs.Value - Now)); |
||||
|
_glibTimerSourceTag = g_timeout_add_once(interval, TimerCallback); |
||||
|
} |
||||
|
|
||||
|
private void TimerCallback() |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
Timer?.Invoke(); |
||||
|
} |
||||
|
catch (Exception e) |
||||
|
{ |
||||
|
HandleException(e); |
||||
|
} |
||||
|
Flush(); |
||||
|
} |
||||
|
|
||||
|
public event Action? ReadyForBackgroundProcessing; |
||||
|
|
||||
|
public void RequestBackgroundProcessing() => |
||||
|
g_idle_add_once(() => ReadyForBackgroundProcessing?.Invoke()); |
||||
|
|
||||
|
public virtual bool CanQueryPendingInput => false; |
||||
|
public virtual bool HasPendingInput => false; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Flush any pending output to the platform event source after Avalonia jobs ran. Called whenever control
|
||||
|
/// returns to GLib from a signaled/timer callback. The base implementation does nothing; backends that own a
|
||||
|
/// socket (e.g. X11) override it to flush their connection.
|
||||
|
/// </summary>
|
||||
|
protected virtual void Flush() |
||||
|
{ |
||||
|
} |
||||
|
|
||||
|
/// <summary>The cancellation token of the innermost Avalonia-controlled run loop frame, or None when no frame
|
||||
|
/// is running. Backends use it to stop draining their event source once a loop frame asked to quit.</summary>
|
||||
|
protected CancellationToken CurrentLoopCancellation => |
||||
|
_runLoopStack.Count > 0 ? _runLoopStack.Peek().Cancelled : CancellationToken.None; |
||||
|
|
||||
|
public void RunLoop(CancellationToken token) |
||||
|
{ |
||||
|
if(token.IsCancellationRequested) |
||||
|
return; |
||||
|
|
||||
|
using var loop = new ManagedLoopFrame(token); |
||||
|
_runLoopStack.Push(loop); |
||||
|
loop.Run(); |
||||
|
_runLoopStack.Pop(); |
||||
|
|
||||
|
// Propagate any managed exceptions that we've captured from this frame
|
||||
|
if(loop.Exceptions.Count == 1) |
||||
|
loop.Exceptions[0].Throw(); |
||||
|
else if (loop.Exceptions.Count > 1) |
||||
|
throw new AggregateException(loop.Exceptions.Select(x => x.SourceException)); |
||||
|
} |
||||
|
|
||||
|
protected void HandleException(Exception e) |
||||
|
{ |
||||
|
if (_runLoopStack.Count > 0) |
||||
|
{ |
||||
|
var frame = _runLoopStack.Peek(); |
||||
|
frame.Exceptions.Add(ExceptionDispatchInfo.Capture(e)); |
||||
|
frame.Stop(); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
if (_externalExceptionLogger != null) |
||||
|
_externalExceptionLogger.Invoke(e); |
||||
|
else |
||||
|
Logger.TryGet(LogEventLevel.Error, LogArea.Control) |
||||
|
?.Log("Dispatcher", "Unhandled exception: {exception}", e); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
private class ManagedLoopFrame : IDisposable |
||||
|
{ |
||||
|
private readonly CancellationToken _externalToken; |
||||
|
private CancellationTokenSource? _internalTokenSource; |
||||
|
public CancellationToken Cancelled { get; private set; } |
||||
|
|
||||
|
private readonly IntPtr _loop = g_main_loop_new(IntPtr.Zero, 1); |
||||
|
public List<ExceptionDispatchInfo> Exceptions { get; } = new(); |
||||
|
private readonly object _destroyLock = new(); |
||||
|
private bool _disposed; |
||||
|
|
||||
|
public ManagedLoopFrame(CancellationToken token) |
||||
|
{ |
||||
|
_externalToken = token; |
||||
|
} |
||||
|
|
||||
|
public void Stop() |
||||
|
{ |
||||
|
try |
||||
|
{ |
||||
|
_internalTokenSource?.Cancel(); |
||||
|
} |
||||
|
catch |
||||
|
{ |
||||
|
// Ignore
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void Run() |
||||
|
{ |
||||
|
if (_externalToken.IsCancellationRequested) |
||||
|
return; |
||||
|
using (_internalTokenSource = new()) |
||||
|
using (var composite = |
||||
|
CancellationTokenSource.CreateLinkedTokenSource(_externalToken, _internalTokenSource.Token)) |
||||
|
{ |
||||
|
Cancelled = composite.Token; |
||||
|
using (Cancelled.Register(() => |
||||
|
{ |
||||
|
lock (_destroyLock) |
||||
|
{ |
||||
|
if (_disposed) |
||||
|
return; |
||||
|
g_main_loop_quit(_loop); |
||||
|
} |
||||
|
})) |
||||
|
{ |
||||
|
g_main_loop_run(_loop); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
lock (_destroyLock) |
||||
|
{ |
||||
|
if(_disposed) |
||||
|
return; |
||||
|
_disposed = true; |
||||
|
g_main_loop_unref(_loop); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue