Branch data Line data Source code
1 : : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
2 : : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
3 : : // SPDX-FileCopyrightText: 2017 Endless Mobile, Inc.
4 : : // SPDX-FileCopyrightText: 2021 Canonical Ltd.
5 : : // SPDX-FileContributor: Authored by: Philip Chimento <philip@endlessm.com>
6 : : // SPDX-FileContributor: Philip Chimento <philip.chimento@gmail.com>
7 : : // SPDX-FileContributor: Marco Trevisan <marco.trevisan@canonical.com>
8 : :
9 : : #include <config.h>
10 : :
11 : : #include <algorithm> // for find_if
12 : : #include <atomic>
13 : : #include <deque>
14 : : #include <utility> // for pair
15 : :
16 : : #include "gi/object.h"
17 : : #include "gi/toggle.h"
18 : : #include "util/log.h"
19 : :
20 : : /* No-op unless GJS_VERBOSE_ENABLE_LIFECYCLE is defined to 1. */
21 : 3731 : inline void debug(const char* did GJS_USED_VERBOSE_LIFECYCLE,
22 : : const ObjectInstance* object GJS_USED_VERBOSE_LIFECYCLE) {
23 : : gjs_debug_lifecycle(GJS_DEBUG_GOBJECT, "ToggleQueue %s %p (%s @ %p)", did,
24 : : object, object ? g_type_name(object->gtype()) : "",
25 : : object ? object->ptr() : nullptr);
26 : 3731 : }
27 : :
28 : 9045 : void ToggleQueue::lock() {
29 : 9045 : auto holding_thread = std::thread::id();
30 : 9045 : auto current_thread = std::this_thread::get_id();
31 : :
32 [ + + ]: 708136 : while (!m_holder.compare_exchange_weak(holding_thread, current_thread,
33 : : std::memory_order_acquire)) {
34 : : // In case the current thread is holding the lock, we can just try
35 : : // again, checking if this is still true and in case continue
36 [ + + ]: 690046 : if (holding_thread != current_thread)
37 : 686725 : holding_thread = std::thread::id();
38 : : }
39 : :
40 : 9045 : m_holder_ref_count++;
41 : 9045 : }
42 : :
43 : 9045 : void ToggleQueue::maybe_unlock() {
44 : 9045 : g_assert(owns_lock() && "Nothing to unlock here");
45 : :
46 [ + + ]: 9045 : if (!(--m_holder_ref_count))
47 : 5724 : m_holder.store(std::thread::id(), std::memory_order_release);
48 : 9045 : }
49 : :
50 : 94 : std::deque<ToggleQueue::Item>::iterator ToggleQueue::find_operation_locked(
51 : : const ObjectInstance* obj, ToggleQueue::Direction direction) {
52 : : return std::find_if(
53 : 188 : q.begin(), q.end(), [obj, direction](const Item& item) -> bool {
54 [ + + + + ]: 58 : return item.object == obj && item.direction == direction;
55 : 188 : });
56 : : }
57 : :
58 : : std::deque<ToggleQueue::Item>::const_iterator
59 : 8550 : ToggleQueue::find_operation_locked(const ObjectInstance* obj,
60 : : ToggleQueue::Direction direction) const {
61 : : return std::find_if(
62 : 17100 : q.begin(), q.end(), [obj, direction](const Item& item) -> bool {
63 [ + + + + ]: 55 : return item.object == obj && item.direction == direction;
64 : 17100 : });
65 : : }
66 : :
67 : 801 : void ToggleQueue::handle_all_toggles(Handler handler) {
68 : 801 : g_assert(owns_lock() && "Unsafe access to queue");
69 [ + + ]: 823 : while (handle_toggle(handler))
70 : : ;
71 : 801 : }
72 : :
73 : : gboolean
74 : 22 : ToggleQueue::idle_handle_toggle(void *data)
75 : : {
76 : 22 : auto self = Locked(static_cast<ToggleQueue*>(data));
77 : 22 : self->handle_all_toggles(self->m_toggle_handler);
78 : :
79 : 44 : return G_SOURCE_REMOVE;
80 : 22 : }
81 : :
82 : : void
83 : 33 : ToggleQueue::idle_destroy_notify(void *data)
84 : : {
85 : 33 : auto self = Locked(static_cast<ToggleQueue*>(data));
86 : 33 : self->m_idle_id = 0;
87 : 33 : self->m_toggle_handler = nullptr;
88 : 33 : }
89 : :
90 : 4275 : std::pair<bool, bool> ToggleQueue::is_queued(ObjectInstance* obj) const {
91 : 4275 : g_assert(owns_lock() && "Unsafe access to queue");
92 : 4275 : bool has_toggle_down = find_operation_locked(obj, DOWN) != q.end();
93 : 4275 : bool has_toggle_up = find_operation_locked(obj, UP) != q.end();
94 : 4275 : return {has_toggle_down, has_toggle_up};
95 : : }
96 : :
97 : 3360 : std::pair<bool, bool> ToggleQueue::cancel(ObjectInstance* obj) {
98 : 3360 : debug("cancel", obj);
99 : 3360 : g_assert(owns_lock() && "Unsafe access to queue");
100 : 3360 : bool had_toggle_down = false;
101 : 3360 : bool had_toggle_up = false;
102 : :
103 [ + + ]: 3368 : for (auto it = q.begin(); it != q.end();) {
104 [ + - ]: 8 : if (it->object == obj) {
105 : 8 : had_toggle_down |= (it->direction == Direction::DOWN);
106 : 8 : had_toggle_up |= (it->direction == Direction::UP);
107 : 8 : it = q.erase(it);
108 : 8 : continue;
109 : : }
110 : 0 : it++;
111 : : }
112 : :
113 : : gjs_debug_lifecycle(GJS_DEBUG_GOBJECT, "ToggleQueue: %p (%p) was %s", obj,
114 : : obj ? obj->ptr() : nullptr,
115 : : had_toggle_down && had_toggle_up
116 : : ? "queued to toggle BOTH"
117 : : : had_toggle_down ? "queued to toggle DOWN"
118 : : : had_toggle_up ? "queued to toggle UP"
119 : : : "not queued");
120 : 3360 : return {had_toggle_down, had_toggle_up};
121 : : }
122 : :
123 : 823 : bool ToggleQueue::handle_toggle(Handler handler) {
124 : 823 : g_assert(owns_lock() && "Unsafe access to queue");
125 : :
126 [ + + ]: 823 : if (q.empty())
127 : 801 : return false;
128 : :
129 : 22 : auto const& item = q.front();
130 [ + + ]: 22 : if (item.direction == UP)
131 : 17 : debug("handle UP", item.object);
132 : : else
133 : 5 : debug("handle DOWN", item.object);
134 : :
135 : 22 : handler(item.object, item.direction);
136 : 22 : q.pop_front();
137 : :
138 : 22 : return true;
139 : : }
140 : :
141 : : void
142 : 255 : ToggleQueue::shutdown(void)
143 : : {
144 : 255 : debug("shutdown", nullptr);
145 : 255 : g_assert(((void)"Queue should have been emptied before shutting down",
146 : : q.empty()));
147 : 255 : m_shutdown = true;
148 : 255 : }
149 : :
150 : 96 : void ToggleQueue::enqueue(ObjectInstance* obj, ToggleQueue::Direction direction,
151 : : // https://trac.cppcheck.net/ticket/10733
152 : : // cppcheck-suppress passedByValue
153 : : ToggleQueue::Handler handler) {
154 : 96 : g_assert(owns_lock() && "Unsafe access to queue");
155 : :
156 [ + + ]: 96 : if (G_UNLIKELY (m_shutdown)) {
157 : 4 : gjs_debug(GJS_DEBUG_GOBJECT,
158 : : "Enqueuing GObject %p to toggle %s after "
159 : : "shutdown, probably from another thread (%p).",
160 [ + - ]: 2 : obj->ptr(), direction == UP ? "UP" : "DOWN", g_thread_self());
161 : 63 : return;
162 : : }
163 : :
164 : 94 : auto other_item = find_operation_locked(obj, direction == UP ? DOWN : UP);
165 [ + + ]: 94 : if (other_item != q.end()) {
166 [ + + ]: 32 : if (direction == UP) {
167 : 5 : debug("enqueue UP, dequeuing already DOWN object", obj);
168 : : } else {
169 : 27 : debug("enqueue DOWN, dequeuing already UP object", obj);
170 : : }
171 : 32 : q.erase(other_item);
172 : 32 : return;
173 : : }
174 : :
175 : : /* Only keep an unowned reference on the object here, as if we're here, the
176 : : * JSObject wrapper has already a reference and we don't want to cause
177 : : * any weak notify in case it has lost one already in the main thread.
178 : : * So let's just save the pointer to keep track of the object till we
179 : : * don't handle this toggle.
180 : : * We rely on object's cancelling the queue in case an object gets
181 : : * finalized earlier than we've processed it.
182 : : */
183 : 62 : q.emplace_back(obj, direction);
184 : :
185 [ + + ]: 62 : if (direction == UP) {
186 : 52 : debug("enqueue UP", obj);
187 : : } else {
188 : 10 : debug("enqueue DOWN", obj);
189 : : }
190 : :
191 [ + + ]: 62 : if (m_idle_id) {
192 : 29 : g_assert(((void) "Should always enqueue with the same handler",
193 : : m_toggle_handler == handler));
194 : 29 : return;
195 : : }
196 : :
197 : 33 : m_toggle_handler = handler;
198 : 33 : m_idle_id = g_idle_add_full(G_PRIORITY_HIGH, idle_handle_toggle, this,
199 : : idle_destroy_notify);
200 : : }
|
