mirrors/sway
1
0
Fork 0
mirror of https://github.com/swaywm/sway.git synced 2026-04-21 06:46:22 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Standardise debug variables

Browse source 
This makes all debug options stored in a single struct rather than in
various places, changes/fixes the behaviour of existing options, and
introduces some new options.

* Fixes damage issues with `-Drender-tree` texture (by removing scissor)
* Offsets the render tree overlay's `y` position for those who have
swaybar at the top
* Replaces `-Ddamage=rerender` with `-Dnodamage`
* Replaces `-Ddamage=highlight` with `-Dhighlight-damage`
* Replaces `-Dtxn-debug` with `-Dtxn-wait`
* Introduces `-Dnoatomic`
* Removes the `create_time` and `ms_arranging` figures from transactions
and the log message. Transactions are created after arranging and the
create time is of no significance.
* Fixes `-Dtxn-debug` (now `-Dtxn-wait`) not working.
This commit is contained in:
Ryan Dwyer 2018-08-18 16:58:50 +10:00
parent 389d159c81
commit 8d1dd03823
7 changed files with 64 additions and 78 deletions
Download patch file Download diff file Expand all files Collapse all files

57
sway/desktop/transaction.c
View file

@ -1,5 +1,6 @@
#define _POSIX_C_SOURCE 200809L
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
@ -16,26 +17,12 @@
#include "list.h"
#include "log.h"
/**
* How long we should wait for views to respond to the configure before giving
* up and applying the transaction anyway.
*/
int txn_timeout_ms = 200;
/**
* If enabled, sway will always wait for the transaction timeout before
* applying it, rather than applying it when the views are ready. This allows us
* to observe the rendered state while a transaction is in progress.
*/
bool txn_debug = false;
struct sway_transaction {
struct wl_event_source *timer;
list_t *instructions; // struct sway_transaction_instruction *
size_t num_waiting;
size_t num_configures;
uint32_t con_ids; // Bitwise XOR of view container IDs
struct timespec create_time;
struct timespec commit_time;
};
@ -53,9 +40,6 @@ static struct sway_transaction *transaction_create() {
return NULL;
}
transaction->instructions = create_list();
if (server.debug_txn_timings) {
clock_gettime(CLOCK_MONOTONIC, &transaction->create_time);
}
return transaction;
}
@ -149,19 +133,14 @@ static void transaction_add_container(struct sway_transaction *transaction,
*/
static void transaction_apply(struct sway_transaction *transaction) {
wlr_log(WLR_DEBUG, "Applying transaction %p", transaction);
if (server.debug_txn_timings) {
if (debug.txn_timings) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
struct timespec *create = &transaction->create_time;
struct timespec *commit = &transaction->commit_time;
float ms_arranging = (commit->tv_sec - create->tv_sec) * 1000 +
(commit->tv_nsec - create->tv_nsec) / 1000000.0;
float ms_waiting = (now.tv_sec - commit->tv_sec) * 1000 +
float ms = (now.tv_sec - commit->tv_sec) * 1000 +
(now.tv_nsec - commit->tv_nsec) / 1000000.0;
float ms_total = ms_arranging + ms_waiting;
wlr_log(WLR_DEBUG, "Transaction %p: %.1fms arranging, %.1fms waiting, "
"%.1fms total (%.1f frames if 60Hz)", transaction,
ms_arranging, ms_waiting, ms_total, ms_total / (1000.0f / 60));
wlr_log(WLR_DEBUG, "Transaction %p: %.1fms waiting "
"(%.1f frames if 60Hz)", transaction, ms, ms / (1000.0f / 60));
}
// Apply the instruction state to the container's current state
@ -310,25 +289,30 @@ static void transaction_commit(struct sway_transaction *transaction) {
con->instruction = instruction;
}
transaction->num_configures = transaction->num_waiting;
if (server.debug_txn_timings) {
if (debug.txn_timings) {
clock_gettime(CLOCK_MONOTONIC, &transaction->commit_time);
}
if (debug.noatomic) {
transaction->num_waiting = 0;
} else if (debug.txn_wait) {
// Force the transaction to time out even if all views are ready.
// We do this by inflating the waiting counter.
transaction->num_waiting += 1000000;
}
if (transaction->num_waiting) {
// Set up a timer which the views must respond within
transaction->timer = wl_event_loop_add_timer(server.wl_event_loop,
handle_timeout, transaction);
if (transaction->timer) {
wl_event_source_timer_update(transaction->timer, txn_timeout_ms);
wl_event_source_timer_update(transaction->timer,
server.txn_timeout_ms);
} else {
wlr_log(WLR_ERROR, "Unable to create transaction timer (%s). "
"Some imperfect frames might be rendered.",
strerror(errno));
handle_timeout(transaction);
transaction->num_waiting = 0;
}
} else {
wlr_log(WLR_DEBUG,
"Transaction %p has nothing to wait for", transaction);
}
// The debug tree shows the pending/live tree. Here is a good place to
@ -341,7 +325,7 @@ static void set_instruction_ready(
struct sway_transaction_instruction *instruction) {
struct sway_transaction *transaction = instruction->transaction;
if (server.debug_txn_timings) {
if (debug.txn_timings) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
struct timespec *start = &transaction->commit_time;
@ -352,15 +336,12 @@ static void set_instruction_ready(
transaction->num_configures - transaction->num_waiting + 1,
transaction->num_configures, ms,
instruction->container->name);
}
// If the transaction has timed out then its num_waiting will be 0 already.
if (transaction->num_waiting > 0 && --transaction->num_waiting == 0) {
if (!txn_debug) {
wlr_log(WLR_DEBUG, "Transaction %p is ready", transaction);
wl_event_source_timer_update(transaction->timer, 0);
}
wlr_log(WLR_DEBUG, "Transaction %p is ready", transaction);
wl_event_source_timer_update(transaction->timer, 0);
}
instruction->container->instruction = NULL;