mirrors/wlroots
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2026-04-17 06:46:39 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'surface-transactions' into 'master'

Browse source 
Draft: compositor: add state transactions

Closes #3787

See merge request wlroots/wlroots!4507
This commit is contained in:
Kirill Primak 2024-10-17 10:19:30 +00:00
commit 52781abd00
11 changed files with 645 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

1
types/meson.build
View file

@ -40,6 +40,7 @@ wlr_files += files(
'wlr_cursor.c',
'wlr_damage_ring.c',
'wlr_data_control_v1.c',
'wlr_dbg_txn.c',
'wlr_drm.c',
'wlr_export_dmabuf_v1.c',
'wlr_foreign_toplevel_management_v1.c',

377
types/wlr_compositor.c
View file

@ -19,6 +19,19 @@
#define COMPOSITOR_VERSION 6
#define CALLBACK_VERSION 1
struct wlr_surface_state_group_entry {
struct wlr_surface_state_group *group;
struct wlr_surface *surface;
struct wlr_surface_state *state;
struct wl_listener surface_destroy;
};
struct wlr_surface_state_group {
size_t n_entries;
size_t n_waiting;
struct wlr_surface_state_group_entry entries[];
};
static int min(int fst, int snd) {
if (fst < snd) {
return fst;
@ -468,11 +481,13 @@ static void surface_update_input_region(struct wlr_surface *surface) {
0, 0, surface->current.width, surface->current.height);
}
static bool surface_state_init(struct wlr_surface_state *state,
struct wlr_surface *surface);
static bool surface_state_init(struct wlr_surface_state *state, struct wlr_surface *surface);
static void surface_state_finish(struct wlr_surface_state *state);
static void surface_cache_pending(struct wlr_surface *surface) {
static bool transaction_commit(struct wlr_surface_transaction *txn,
struct wlr_surface *commit_surface);
static struct wlr_surface_state *surface_cache_pending(struct wlr_surface *surface) {
struct wlr_surface_state *cached = calloc(1, sizeof(*cached));
if (!cached) {
goto error;
@ -498,7 +513,7 @@ static void surface_cache_pending(struct wlr_surface *surface) {
surface->pending.seq++;
return;
return cached;
error_state:
surface_state_finish(cached);
@ -506,11 +521,12 @@ error_cached:
free(cached);
error:
wl_resource_post_no_memory(surface->resource);
return NULL;
}
static void surface_commit_state(struct wlr_surface *surface,
struct wlr_surface_state *next) {
static void surface_commit_state(struct wlr_surface *surface, struct wlr_surface_state *next) {
assert(next->cached_state_locks == 0);
assert(next->group == NULL);
bool invalid_buffer = next->committed & WLR_SURFACE_STATE_BUFFER;
@ -578,17 +594,21 @@ static void surface_handle_commit(struct wl_client *client,
surface->role->client_commit(surface);
}
wl_signal_emit_mutable(&surface->events.client_commit, NULL);
struct wlr_surface_transaction txn;
wlr_surface_transaction_init(&txn, &surface->txn_buffer);
surface->handling_commit = false;
if (surface->pending_rejected) {
return;
}
if (surface->pending.cached_state_locks > 0 || !wl_list_empty(&surface->cached)) {
surface_cache_pending(surface);
} else {
surface_commit_state(surface, &surface->pending);
struct wlr_surface_client_commit_event event = {
.transaction = &txn,
};
wl_signal_emit_mutable(&surface->events.client_commit, &event);
if (!transaction_commit(&txn, surface)) {
wl_resource_post_no_memory(resource);
}
}
@ -718,6 +738,9 @@ static void surface_destroy_role_object(struct wlr_surface *surface);
static void surface_handle_resource_destroy(struct wl_resource *resource) {
struct wlr_surface *surface = wlr_surface_from_resource(resource);
assert(surface->txn_state == NULL &&
"Tried to destroy a surface which was a part of a transaction");
struct wlr_surface_output *surface_output, *surface_output_tmp;
wl_list_for_each_safe(surface_output, surface_output_tmp,
&surface->current_outputs, link) {
@ -736,6 +759,8 @@ static void surface_handle_resource_destroy(struct wl_resource *resource) {
surface_state_destroy_cached(cached, surface);
}
wl_array_release(&surface->txn_buffer);
wl_list_remove(&surface->role_resource_destroy.link);
wl_list_remove(&surface->pending_buffer_resource_destroy.link);
@ -789,6 +814,7 @@ static struct wlr_surface *surface_create(struct wl_client *client,
pixman_region32_init(&surface->input_region);
wlr_addon_set_init(&surface->addons);
wl_list_init(&surface->synced);
wl_array_init(&surface->txn_buffer);
wl_list_init(&surface->role_resource_destroy.link);
@ -928,53 +954,324 @@ static void surface_destroy_role_object(struct wlr_surface *surface) {
wl_list_init(&surface->role_resource_destroy.link);
}
uint32_t wlr_surface_lock_pending(struct wlr_surface *surface) {
surface->pending.cached_state_locks++;
return surface->pending.seq;
}
void wlr_surface_unlock_cached(struct wlr_surface *surface, uint32_t seq) {
static struct wlr_surface_state *state_by_seq(struct wlr_surface *surface, uint32_t seq) {
if (surface->pending.seq == seq) {
assert(surface->pending.cached_state_locks > 0);
surface->pending.cached_state_locks--;
return;
return &surface->pending;
}
bool found = false;
struct wlr_surface_state *cached;
wl_list_for_each(cached, &surface->cached, cached_state_link) {
if (cached->seq == seq) {
found = true;
break;
return cached;
}
}
assert(found);
assert(cached->cached_state_locks > 0);
cached->cached_state_locks--;
abort(); // Invalid seq
}
if (cached->cached_state_locks != 0) {
return;
}
// Returns true if the cached state can be applied immediately
static bool cached_state_ready(struct wlr_surface *surface, struct wlr_surface_state *state) {
return state->cached_state_locks == 0 && state->cached_state_link.prev == &surface->cached;
}
if (cached->cached_state_link.prev != &surface->cached) {
// This isn't the first cached state. This means we're blocked on a
// previous cached state.
return;
}
static void group_notify_ready(struct wlr_surface_state_group *group);
// TODO: consider merging all committed states together
struct wlr_surface_state *next, *tmp;
wl_list_for_each_safe(next, tmp, &surface->cached, cached_state_link) {
if (next->cached_state_locks > 0) {
static void commit_cached_states(struct wlr_surface *surface) {
// TODO: consider merging all committed states together
struct wlr_surface_state *state, *tmp;
wl_list_for_each_safe(state, tmp, &surface->cached, cached_state_link) {
if (state->cached_state_locks > 0) {
break;
} else if (state->group != NULL) {
// XXX: possible stack overflow?
group_notify_ready(state->group);
break;
}
surface_commit_state(surface, next);
surface_state_destroy_cached(next, surface);
surface_commit_state(surface, state);
surface_state_destroy_cached(state, surface);
}
}
static void group_entry_finish(struct wlr_surface_state_group_entry *entry) {
entry->surface = NULL;
entry->state = NULL;
wl_list_remove(&entry->surface_destroy.link);
}
static void group_notify_ready(struct wlr_surface_state_group *group) {
assert(group->n_waiting > 0);
--group->n_waiting;
if (group->n_waiting > 0) {
return;
}
for (size_t i = 0; i < group->n_entries; i++) {
struct wlr_surface_state_group_entry *entry = &group->entries[i];
if (entry->surface == NULL) {
// Surface was destroyed
continue;
}
entry->state->group = NULL;
commit_cached_states(entry->surface);
group_entry_finish(entry);
}
free(group);
}
static void group_entry_handle_surface_destroy(struct wl_listener *listener, void *data) {
struct wlr_surface_state_group_entry *entry =
wl_container_of(listener, entry, surface_destroy);
struct wlr_surface_state_group *group = entry->group;
struct wlr_surface *surface = entry->surface;
struct wlr_surface_state *state = entry->state;
group_entry_finish(entry);
if (!cached_state_ready(surface, state)) {
group_notify_ready(group);
}
}
static void group_add_entry(struct wlr_surface_state_group *group, struct wlr_surface *surface,
struct wlr_surface_state *state) {
struct wlr_surface_state_group_entry *entry = &group->entries[group->n_entries++];
entry->group = group;
entry->surface = surface;
entry->state = state;
entry->surface_destroy.notify = group_entry_handle_surface_destroy;
wl_signal_add(&surface->events.destroy, &entry->surface_destroy);
state->group = group;
}
// Commit a transaction with an optional pending state of commit_surface
static bool transaction_commit(struct wlr_surface_transaction *txn,
struct wlr_surface *commit_surface) {
size_t n_waiting = 0;
struct wlr_surface **iter;
wl_array_for_each(iter, txn->surfaces) {
struct wlr_surface *surface = *iter;
struct wlr_surface_state *state = surface->txn_state;
assert(state->group == NULL);
assert(state->cached_state_locks > 0);
if (state->cached_state_locks > 1 || state->cached_state_link.prev != &surface->cached) {
// The state isn't the first cached one or has locks other than
// the one added to the transaction
++n_waiting;
}
}
size_t n_entries = txn->surfaces->size / sizeof(struct wlr_surface *);
if (n_entries == 0) {
// Fast path: no cached states
if (commit_surface != NULL) {
if (wl_list_empty(&commit_surface->cached) &&
commit_surface->pending.cached_state_locks == 0) {
surface_commit_state(commit_surface, &commit_surface->pending);
} else if (surface_cache_pending(commit_surface) == NULL) {
return false;
}
}
return true;
} else if (n_entries == 1 && commit_surface == NULL) {
// Fast path: one cached state, no pending state
struct wlr_surface *surface = ((struct wlr_surface **)txn->surfaces->data)[0];
--surface->txn_state->cached_state_locks;
surface->txn_state = NULL;
commit_cached_states(surface);
return true;
}
if (commit_surface != NULL) {
if (!wl_list_empty(&commit_surface->cached) ||
commit_surface->pending.cached_state_locks > 0) {
++n_waiting;
}
}
if (n_waiting == 0) {
// Fast path: all states can be applied immediately
// Unlock and unset txn_state separately so commit listeners won't get
// a surface which is still in a transaction
wl_array_for_each(iter, txn->surfaces) {
struct wlr_surface *surface = *iter;
--surface->txn_state->cached_state_locks;
surface->txn_state = NULL;
}
// Then, apply everything
wl_array_for_each(iter, txn->surfaces) {
commit_cached_states(*iter);
}
if (commit_surface != NULL) {
surface_commit_state(commit_surface, &commit_surface->pending);
}
return true;
}
// "Slow" path
struct wlr_surface_state *commit_state = NULL;
if (commit_surface != NULL) {
commit_state = surface_cache_pending(commit_surface);
if (commit_state == NULL) {
goto error;
}
++n_entries;
}
struct wlr_surface_state_group *group =
calloc(1, sizeof(*group) + n_entries * sizeof(*group->entries));
if (group == NULL) {
if (commit_surface != NULL) {
commit_cached_states(commit_surface);
}
goto error;
}
wl_array_for_each(iter, txn->surfaces) {
struct wlr_surface *surface = *iter;
--surface->txn_state->cached_state_locks;
group_add_entry(group, surface, surface->txn_state);
surface->txn_state = NULL;
}
if (commit_state != NULL) {
group_add_entry(group, commit_surface, commit_state);
}
group->n_waiting = n_waiting;
return true;
error:
wlr_surface_transaction_drop(txn);
return false;
}
static void state_lock_handle_surface_destroy(struct wl_listener *listener, void *data) {
struct wlr_surface_state_lock *lock = wl_container_of(listener, lock, surface_destroy);
wlr_surface_state_lock_release(lock);
}
void wlr_surface_state_lock_acquire(struct wlr_surface_state_lock *lock,
struct wlr_surface *surface) {
assert(lock->surface == NULL && "Tried to acquire a locked lock");
lock->surface = surface;
lock->seq = surface->pending.seq;
++surface->pending.cached_state_locks;
lock->surface_destroy.notify = state_lock_handle_surface_destroy;
wl_signal_add(&surface->events.destroy, &lock->surface_destroy);
}
void wlr_surface_state_lock_release(struct wlr_surface_state_lock *lock) {
struct wlr_surface *surface = lock->surface;
if (surface == NULL) {
// Already unlocked
return;
}
lock->surface = NULL;
wl_list_remove(&lock->surface_destroy.link);
struct wlr_surface_state *state = state_by_seq(surface, lock->seq);
--state->cached_state_locks;
if (state == &surface->pending) {
return;
}
commit_cached_states(surface);
}
bool wlr_surface_state_lock_locked(struct wlr_surface_state_lock *lock) {
return lock->surface != NULL;
}
void wlr_surface_transaction_init(struct wlr_surface_transaction *txn, struct wl_array *buffer) {
txn->surfaces = buffer;
buffer->size = 0;
}
bool wlr_surface_transaction_add_lock(struct wlr_surface_transaction *txn,
struct wlr_surface_state_lock *lock) {
struct wlr_surface *surface = lock->surface;
assert(surface != NULL);
struct wlr_surface_state *state = state_by_seq(surface, lock->seq);
if (surface->txn_state == state) {
// Already added
--state->cached_state_locks;
goto release;
}
assert(surface->txn_state == NULL &&
"Tried to add locks for different states of the same surface");
if (state == &surface->pending) {
// No cached state to add
--state->cached_state_locks;
goto release;
}
struct wlr_surface_state_group *group = state->group;
if (group != NULL) {
// Add the whole group instead
struct wlr_surface **ptr = wl_array_add(txn->surfaces, sizeof(surface) * group->n_entries);
if (ptr == NULL) {
return false;
}
for (size_t i = 0; i < group->n_entries; i++) {
struct wlr_surface_state_group_entry *entry = &group->entries[i];
assert(entry->surface->txn_state == NULL);
ptr[i] = entry->surface;
entry->surface->txn_state = entry->state;
entry->state->group = NULL;
++entry->state->cached_state_locks;
group_entry_finish(entry);
}
free(group);
--state->cached_state_locks;
goto release;
}
struct wlr_surface **ptr = wl_array_add(txn->surfaces, sizeof(surface));
if (ptr == NULL) {
return false;
}
*ptr = surface;
surface->txn_state = state;
release:
lock->surface = NULL;
wl_list_remove(&lock->surface_destroy.link);
return true;
}
void wlr_surface_transaction_drop(struct wlr_surface_transaction *txn) {
struct wlr_surface **surfaces = txn->surfaces->data;
size_t n_surfaces = txn->surfaces->size / sizeof(*surfaces);
for (size_t i = 0; i < n_surfaces; i++) {
struct wlr_surface *surface = surfaces[i];
struct wlr_surface_state *state = surface->txn_state;
surface->txn_state = NULL;
--state->cached_state_locks;
commit_cached_states(surface);
}
}
bool wlr_surface_transaction_commit(struct wlr_surface_transaction *txn) {
return transaction_commit(txn, NULL);
}
struct wlr_surface *wlr_surface_get_root_surface(struct wlr_surface *surface) {
struct wlr_subsurface *subsurface;
while ((subsurface = wlr_subsurface_try_from_wlr_surface(surface))) {

157
types/wlr_dbg_txn.c Normal file
View file

@ -0,0 +1,157 @@
#include <assert.h>
#include <stdlib.h>
#include <wlr/types/wlr_compositor.h>
#include <wlr/types/wlr_dbg_txn.h>
struct wlr_dbg_txn {
struct wl_resource *resource;
struct wl_list locks;
};
struct wlr_dbg_txn_lock {
struct wlr_addon addon;
struct wlr_surface_state_lock lock;
struct wl_list link;
};
static const struct dbg_txn_interface txn_impl;
static struct wlr_dbg_txn *txn_from_resource(struct wl_resource *resource) {
assert(wl_resource_instance_of(resource, &dbg_txn_interface, &txn_impl));
return wl_resource_get_user_data(resource);
}
static void txn_lock_destroy(struct wlr_dbg_txn_lock *lock) {
wlr_surface_state_lock_release(&lock->lock);
wl_list_remove(&lock->link);
wlr_addon_finish(&lock->addon);
free(lock);
}
static void addon_handle_destroy(struct wlr_addon *addon) {
struct wlr_dbg_txn_lock *lock = wl_container_of(addon, lock, addon);
txn_lock_destroy(lock);
}
static struct wlr_addon_interface addon_impl = {
.name = "wlr_dbg_txn_lock",
.destroy = addon_handle_destroy,
};
static void txn_handle_add_surface(struct wl_client *client, struct wl_resource *resource,
struct wl_resource *surface_resource) {
struct wlr_surface *surface = wlr_surface_from_resource(surface_resource);
if (wlr_addon_find(&surface->addons, NULL, &addon_impl) != NULL) {
wl_resource_post_error(resource, -1, "already added");
return;
}
struct wlr_dbg_txn *txn = txn_from_resource(resource);
struct wlr_dbg_txn_lock *lock = calloc(1, sizeof(*lock));
assert(lock != NULL);
wlr_surface_state_lock_acquire(&lock->lock, surface);
wl_list_insert(&txn->locks, &lock->link);
wlr_addon_init(&lock->addon, &surface->addons, NULL, &addon_impl);
}
static void txn_handle_commit(struct wl_client *client, struct wl_resource *resource) {
struct wlr_dbg_txn *txn = txn_from_resource(resource);
struct wl_array buffer;
wl_array_init(&buffer);
struct wlr_surface_transaction surface_txn;
wlr_surface_transaction_init(&surface_txn, &buffer);
bool ok = true;
struct wlr_dbg_txn_lock *lock;
wl_list_for_each(lock, &txn->locks, link) {
if (!wlr_surface_transaction_add_lock(&surface_txn, &lock->lock)) {
wlr_surface_transaction_drop(&surface_txn);
ok = false;
break;
}
}
if (ok) {
ok = wlr_surface_transaction_commit(&surface_txn);
}
if (!ok) {
wl_resource_post_no_memory(resource);
}
wl_array_release(&buffer);
wl_resource_destroy(resource);
}
static const struct dbg_txn_interface txn_impl = {
.add_surface = txn_handle_add_surface,
.commit = txn_handle_commit,
};
static void txn_handle_resource_destroy(struct wl_resource *resource) {
struct wlr_dbg_txn *txn = txn_from_resource(resource);
struct wlr_dbg_txn_lock *lock, *tmp;
wl_list_for_each_safe(lock, tmp, &txn->locks, link) {
txn_lock_destroy(lock);
}
free(txn);
}
static void manager_handle_get_txn(struct wl_client *client,
struct wl_resource *resource, uint32_t id) {
struct wlr_dbg_txn *txn = calloc(1, sizeof(*txn));
if (txn == NULL) {
wl_client_post_no_memory(client);
return;
}
txn->resource = wl_resource_create(client, &dbg_txn_interface, 1, id);
assert(txn->resource != NULL);
wl_resource_set_implementation(txn->resource, &txn_impl, txn, txn_handle_resource_destroy);
wl_list_init(&txn->locks);
}
static const struct dbg_txn_manager_interface manager_impl = {
.get_txn = manager_handle_get_txn,
};
static void manager_bind(struct wl_client *wl_client, void *data, uint32_t version, uint32_t id) {
struct wlr_dbg_txn_manager *manager = data;
struct wl_resource *resource =
wl_resource_create(wl_client, &wl_compositor_interface, version, id);
if (resource == NULL) {
wl_client_post_no_memory(wl_client);
return;
}
wl_resource_set_implementation(resource, &manager_impl, manager, NULL);
}
static void manager_handle_display_destroy(struct wl_listener *listener, void *data) {
struct wlr_dbg_txn_manager *manager = wl_container_of(listener, manager, display_destroy);
wl_list_remove(&manager->display_destroy.link);
wl_global_destroy(manager->global);
free(manager);
}
struct wlr_dbg_txn_manager *wlr_dbg_txn_manager_create(struct wl_display *display) {
struct wlr_dbg_txn_manager *manager = calloc(1, sizeof(*manager));
if (!manager) {
return NULL;
}
manager->global = wl_global_create(display, &dbg_txn_manager_interface,
1, manager, manager_bind);
if (!manager->global) {
free(manager);
return NULL;
}
manager->display_destroy.notify = manager_handle_display_destroy;
wl_display_add_destroy_listener(display, &manager->display_destroy);
return manager;
}

44
types/wlr_subcompositor.c
View file

@ -25,9 +25,7 @@ static bool subsurface_is_synchronized(struct wlr_subsurface *subsurface) {
static const struct wl_subsurface_interface subsurface_implementation;
static void subsurface_destroy(struct wlr_subsurface *subsurface) {
if (subsurface->has_cache) {
wlr_surface_unlock_cached(subsurface->surface, subsurface->cached_seq);
}
wlr_surface_state_lock_release(&subsurface->cached_lock);
wlr_surface_unmap(subsurface->surface);
@ -36,6 +34,7 @@ static void subsurface_destroy(struct wlr_subsurface *subsurface) {
wlr_surface_synced_finish(&subsurface->parent_synced);
wl_list_remove(&subsurface->surface_client_commit.link);
wl_list_remove(&subsurface->parent_client_commit.link);
wl_list_remove(&subsurface->parent_destroy.link);
wl_resource_set_user_data(subsurface->resource, NULL);
@ -170,11 +169,8 @@ static void subsurface_handle_set_desync(struct wl_client *client,
if (subsurface->synchronized) {
subsurface->synchronized = false;
if (!subsurface_is_synchronized(subsurface) &&
subsurface->has_cache) {
wlr_surface_unlock_cached(subsurface->surface,
subsurface->cached_seq);
subsurface->has_cache = false;
if (!subsurface_is_synchronized(subsurface)) {
wlr_surface_state_lock_release(&subsurface->cached_lock);
}
}
}
@ -248,10 +244,19 @@ static struct wlr_surface_synced_impl surface_synced_impl = {
.move_state = surface_synced_move_state,
};
static void subsurface_handle_parent_destroy(struct wl_listener *listener,
void *data) {
static void subsurface_handle_parent_client_commit(struct wl_listener *listener, void *data) {
struct wlr_subsurface *subsurface =
wl_container_of(listener, subsurface, parent_destroy);
wl_container_of(listener, subsurface, parent_client_commit);
struct wlr_surface_client_commit_event *event = data;
if (wlr_surface_state_lock_locked(&subsurface->cached_lock)) {
if (!wlr_surface_transaction_add_lock(event->transaction, &subsurface->cached_lock)) {
wl_resource_post_no_memory(subsurface->resource);
}
}
}
static void subsurface_handle_parent_destroy(struct wl_listener *listener, void *data) {
struct wlr_subsurface *subsurface = wl_container_of(listener, subsurface, parent_destroy);
// Once the parent is destroyed, the client has no way to use the
// wl_subsurface object anymore, so we can destroy it.
subsurface_destroy(subsurface);
@ -264,23 +269,20 @@ static void subsurface_handle_surface_client_commit(
struct wlr_surface *surface = subsurface->surface;
if (subsurface_is_synchronized(subsurface)) {
if (subsurface->has_cache) {
if (wlr_surface_state_lock_locked(&subsurface->cached_lock)) {
// We already lock a previous commit. The prevents any future
// commit to be applied before we release the previous commit.
return;
}
subsurface->has_cache = true;
subsurface->cached_seq = wlr_surface_lock_pending(surface);
} else if (subsurface->has_cache) {
wlr_surface_unlock_cached(surface, subsurface->cached_seq);
subsurface->has_cache = false;
wlr_surface_state_lock_acquire(&subsurface->cached_lock, surface);
} else {
wlr_surface_state_lock_release(&subsurface->cached_lock);
}
}
void subsurface_handle_parent_commit(struct wlr_subsurface *subsurface) {
if (subsurface->synchronized && subsurface->has_cache) {
wlr_surface_unlock_cached(subsurface->surface, subsurface->cached_seq);
subsurface->has_cache = false;
if (subsurface->synchronized) {
wlr_surface_state_lock_release(&subsurface->cached_lock);
}
if (!subsurface->added) {
@ -375,6 +377,8 @@ static void subcompositor_handle_get_subsurface(struct wl_client *client,
// link parent
subsurface->parent = parent;
wl_signal_add(&parent->events.client_commit, &subsurface->parent_client_commit);
subsurface->parent_client_commit.notify = subsurface_handle_parent_client_commit;
wl_signal_add(&parent->events.destroy, &subsurface->parent_destroy);
subsurface->parent_destroy.notify = subsurface_handle_parent_destroy;