Atomic and mutex can be compared in concurrency performance test.
If you use Atomic package, performance is better than using mutex.
Atomic does not have a data race problem even if two threads access at the same time without mutex.
Change-Id: Ide5733f9fbdb84836f25134753a7cb86aa992fa6
Signed-off-by: Jihoon Kim <jihoon48.kim@samsung.com>
# include <inttypes.h>
# include <assert.h>
+#ifdef __cplusplus
+#include <atomic>
+using namespace std;
+#else
+#include <stdatomic.h>
+#endif
+
# ifndef _POSIX_HOST_NAME_MAX
# define _POSIX_HOST_NAME_MAX 255
# endif
case ECORE_DEVICE_CLASS_MOUSE:
return e_devicemgr->last_device_ptr;
case ECORE_DEVICE_CLASS_KEYBOARD:
- g_rec_mutex_lock(&e_devicemgr->last_device_kbd_mutex);
- last_kbd = e_devicemgr->last_device_kbd;
- g_rec_mutex_unlock(&e_devicemgr->last_device_kbd_mutex);
+ last_kbd = atomic_load(&e_devicemgr->last_device_kbd);
return last_kbd;
case ECORE_DEVICE_CLASS_TOUCH:
return e_devicemgr->last_device_touch;
e_devicemgr->last_device_ptr = device;
break;
case ECORE_DEVICE_CLASS_KEYBOARD:
- g_rec_mutex_lock(&e_devicemgr->last_device_kbd_mutex);
- e_devicemgr->last_device_kbd = device;
- g_rec_mutex_unlock(&e_devicemgr->last_device_kbd_mutex);
+ atomic_store(&e_devicemgr->last_device_kbd, device);
break;
case ECORE_DEVICE_CLASS_TOUCH:
e_devicemgr->last_device_touch = device;
case ECORE_DEVICE_CLASS_MOUSE:
return ec->comp_data->last_device_ptr;
case ECORE_DEVICE_CLASS_KEYBOARD:
- g_rec_mutex_lock(&ec->comp_data->last_device_kbd_mutex);
- last_kbd = ec->comp_data->last_device_kbd;
- g_rec_mutex_unlock(&ec->comp_data->last_device_kbd_mutex);
+ last_kbd = atomic_load(&ec->comp_data->last_device_kbd);
return last_kbd;
case ECORE_DEVICE_CLASS_TOUCH:
return ec->comp_data->last_device_touch;
ec->comp_data->last_device_ptr = device;
break;
case ECORE_DEVICE_CLASS_KEYBOARD:
- g_rec_mutex_lock(&ec->comp_data->last_device_kbd_mutex);
- ec->comp_data->last_device_kbd = device;
- g_rec_mutex_unlock(&ec->comp_data->last_device_kbd_mutex);
+ atomic_store(&ec->comp_data->last_device_kbd, device);
break;
case ECORE_DEVICE_CLASS_TOUCH:
ec->comp_data->last_device_touch = device;
struct wl_array routed_keys;
struct wl_resource *focus;
int mod_changed;
- int repeat_delay;
- int repeat_rate;
+ atomic_int repeat_delay;
+ atomic_int repeat_rate;
unsigned int num_devices;
- GMutex mod_changed_mutex;
GMutex resource_mutex; /* for resources variable */
GMutex focused_mutex; /* for focused variable */
GMutex keys_mutex; /* for keys variable */
Eina_Bool wtz_surface_assigned;
struct wl_list pointer_constraints;
- GRecMutex last_device_kbd_mutex;
GMutex surface_mutex;
struct wl_signal state_commit_signal;
struct wl_resource *res;
Eina_List *l;
uint32_t serial;
+ xkb_mod_mask_t mod_depressed, mod_latched, mod_locked;
+ xkb_layout_index_t mod_group;
+
struct wl_resource *surface = e_comp_wl_client_surface_get(ec);
if (!surface) return;
serial = wl_display_next_serial(e_comp_wl->wl.disp);
- g_mutex_lock(&e_comp_wl->kbd.mod_changed_mutex);
g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
g_mutex_lock(&e_comp_wl->kbd.keys_mutex);
+
+ mod_depressed = atomic_load(&e_comp_wl->kbd.mod_depressed);
+ mod_latched = atomic_load(&e_comp_wl->kbd.mod_latched);
+ mod_locked = atomic_load(&e_comp_wl->kbd.mod_locked);
+
+ mod_group = atomic_load(&e_comp_wl->kbd.mod_group);
+
EINA_LIST_FOREACH(e_comp_wl->kbd.focused, l, res)
{
wl_keyboard_send_enter(res, serial, surface,
&e_comp_wl->kbd.keys);
+
wl_keyboard_send_modifiers(res, serial,
- e_comp_wl->kbd.mod_depressed,
- e_comp_wl->kbd.mod_latched,
- e_comp_wl->kbd.mod_locked,
- e_comp_wl->kbd.mod_group);
+ mod_depressed,
+ mod_latched,
+ mod_locked,
+ mod_group);
}
g_mutex_unlock(&e_comp_wl->kbd.keys_mutex);
g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
- g_mutex_unlock(&e_comp_wl->kbd.mod_changed_mutex);
}
static void
/* send current repeat_info */
if (wl_resource_get_version(res) >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
{
- g_mutex_lock(&e_comp_wl->kbd.repeat_rate_mutex);
- g_mutex_lock(&e_comp_wl->kbd.repeat_delay_mutex);
wl_keyboard_send_repeat_info(res, e_comp_wl->kbd.repeat_rate, e_comp_wl->kbd.repeat_delay);
- g_mutex_unlock(&e_comp_wl->kbd.repeat_delay_mutex);
- g_mutex_unlock(&e_comp_wl->kbd.repeat_rate_mutex);
}
/* send current keymap */
dont_set_e_input_keymap = getenv("NO_E_INPUT_KEYMAP_CACHE") ? EINA_TRUE : EINA_FALSE;
dont_use_xkb_cache = getenv("NO_KEYMAP_CACHE") ? EINA_TRUE : EINA_FALSE;
- g_mutex_init(&e_comp_wl->kbd.mod_changed_mutex);
g_mutex_init(&e_comp_wl->kbd.resource_mutex);
g_mutex_init(&e_comp_wl->kbd.focused_mutex);
g_mutex_init(&e_comp_wl->kbd.keys_mutex);
g_mutex_init(&e_comp_wl->xkb.keymap_mutex);
g_mutex_init(&e_comp_wl->xkb.state_mutex);
- g_mutex_lock(&e_comp_wl->kbd.repeat_delay_mutex);
/* get default keyboard repeat delay from configuration */
- e_comp_wl->kbd.repeat_delay = e_config->keyboard.repeat_delay;
+ atomic_store(&e_comp_wl->kbd.repeat_delay, e_config->keyboard.repeat_delay);
/* check for valid repeat_delay */
/* if invalid, set the default value of repeat delay */
- if (e_comp_wl->kbd.repeat_delay < 0) e_comp_wl->kbd.repeat_delay = 400;
- g_mutex_unlock(&e_comp_wl->kbd.repeat_delay_mutex);
+ if (e_comp_wl->kbd.repeat_delay < 0)
+ atomic_store(&e_comp_wl->kbd.repeat_delay, 400);
- g_mutex_lock(&e_comp_wl->kbd.repeat_rate_mutex);
/* get default keyboard repeat rate from configuration */
- e_comp_wl->kbd.repeat_rate = e_config->keyboard.repeat_rate;
+ atomic_store(&e_comp_wl->kbd.repeat_rate, e_config->keyboard.repeat_rate);
/* check for valid repeat_rate value */
/* if invalid, set the default value of repeat rate value */
- if (e_comp_wl->kbd.repeat_rate < 0) e_comp_wl->kbd.repeat_rate = 25;
- g_mutex_unlock(&e_comp_wl->kbd.repeat_rate_mutex);
+ if (e_comp_wl->kbd.repeat_rate < 0)
+ atomic_store(&e_comp_wl->kbd.repeat_rate, 25);
/* create the global resource for input seat */
e_comp_wl->seat.global =
_surface_commit_hook = NULL;
}
- g_mutex_clear(&e_comp_wl->kbd.mod_changed_mutex);
-
/* destroy pointer resources */
EINA_LIST_FREE(e_comp_wl->ptr.resources, res)
wl_resource_destroy(res);
xkb_mod_mask_t mod;
xkb_layout_index_t grp;
- g_mutex_lock(&e_comp_wl->kbd.mod_changed_mutex);
+ xkb_mod_mask_t mod_depressed, mod_latched, mod_locked;
+ xkb_layout_index_t mod_group;
+
g_mutex_lock(&e_comp_wl->xkb.state_mutex);
mod = xkb_state_serialize_mods(e_comp_wl->xkb.state,
XKB_STATE_DEPRESSED);
- changed |= mod != e_comp_wl->kbd.mod_depressed;
- e_comp_wl->kbd.mod_depressed = mod;
+ mod_depressed = atomic_load(&e_comp_wl->kbd.mod_depressed);
+ changed |= mod != mod_depressed;
+ atomic_store(&e_comp_wl->kbd.mod_depressed, mod);
mod = xkb_state_serialize_mods(e_comp_wl->xkb.state,
XKB_STATE_MODS_LATCHED);
- changed |= mod != e_comp_wl->kbd.mod_latched;
- e_comp_wl->kbd.mod_latched = mod;
+
+ mod_latched = atomic_load(&e_comp_wl->kbd.mod_latched);
+ changed |= mod != mod_latched;
+ atomic_store(&e_comp_wl->kbd.mod_latched, mod);
mod = xkb_state_serialize_mods(e_comp_wl->xkb.state,
XKB_STATE_MODS_LOCKED);
- changed |= mod != e_comp_wl->kbd.mod_locked;
- e_comp_wl->kbd.mod_locked = mod;
+ mod_locked = atomic_load(&e_comp_wl->kbd.mod_locked);
+ changed |= mod != mod_locked;
+ atomic_store(&e_comp_wl->kbd.mod_locked, mod);
grp = xkb_state_serialize_layout(e_comp_wl->xkb.state,
XKB_STATE_LAYOUT_EFFECTIVE);
- changed |= grp != e_comp_wl->kbd.mod_group;
- e_comp_wl->kbd.mod_group = grp;
+ mod_group = atomic_load(&e_comp_wl->kbd.mod_group);
+ changed |= grp != mod_group;
+ atomic_store(&e_comp_wl->kbd.mod_group, grp);
g_mutex_unlock(&e_comp_wl->xkb.state_mutex);
- g_mutex_unlock(&e_comp_wl->kbd.mod_changed_mutex);
return changed;
}
g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
serial = wl_display_next_serial(e_comp_wl->wl.disp);
- g_mutex_lock(&e_comp_wl->kbd.mod_changed_mutex);
g_mutex_lock(&e_comp_wl->kbd.focused_mutex);
EINA_LIST_FOREACH(e_comp_wl->kbd.focused, l, res)
wl_keyboard_send_modifiers(res, serial,
e_comp_wl->kbd.mod_locked,
e_comp_wl->kbd.mod_group);
g_mutex_unlock(&e_comp_wl->kbd.focused_mutex);
- g_mutex_unlock(&e_comp_wl->kbd.mod_changed_mutex);
}
EINTERN void
if (pressed) dir = XKB_KEY_DOWN;
else dir = XKB_KEY_UP;
- e_comp_wl->kbd.mod_changed =
- xkb_state_update_key(e_comp_wl->xkb.state, keycode + 8, dir);
+ atomic_store(&e_comp_wl->kbd.mod_changed, xkb_state_update_key(e_comp_wl->xkb.state, keycode + 8, dir));
g_mutex_unlock(&e_comp_wl->xkb.state_mutex);
EINA_SAFETY_ON_NULL_RETURN(e_comp_wl);
- g_mutex_lock(&e_comp_wl->kbd.repeat_delay_mutex);
- e_comp_wl->kbd.repeat_delay = delay;
- g_mutex_unlock(&e_comp_wl->kbd.repeat_delay_mutex);
-
- g_mutex_lock(&e_comp_wl->kbd.repeat_rate_mutex);
- e_comp_wl->kbd.repeat_rate = rate;
- g_mutex_unlock(&e_comp_wl->kbd.repeat_rate_mutex);
+ atomic_store(&e_comp_wl->kbd.repeat_delay, delay);
+ atomic_store(&e_comp_wl->kbd.repeat_rate, rate);
g_mutex_lock(&e_comp_wl->kbd.resource_mutex);
- g_mutex_lock(&e_comp_wl->kbd.repeat_delay_mutex);
- g_mutex_lock(&e_comp_wl->kbd.repeat_rate_mutex);
EINA_LIST_FOREACH(e_comp_wl->kbd.resources, l, res)
{
if (wl_resource_get_version(res) >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
wl_keyboard_send_repeat_info(res, e_comp_wl->kbd.repeat_rate,
e_comp_wl->kbd.repeat_delay);
}
- g_mutex_unlock(&e_comp_wl->kbd.repeat_rate_mutex);
- g_mutex_unlock(&e_comp_wl->kbd.repeat_delay_mutex);
+
g_mutex_unlock(&e_comp_wl->kbd.resource_mutex);
}
e_pixmap_cdata_set(ec->pixmap, &surface->base);
- g_rec_mutex_init(&ec->comp_data->last_device_kbd_mutex);
g_mutex_init(&ec->comp_data->surface_mutex);
end:
TRACE_DS_BEGIN(COMP_WL:CLIENT DEL CB);
- g_rec_mutex_clear(&ec->comp_data->last_device_kbd_mutex);
-
e_comp_wl_hook_call(E_COMP_WL_HOOK_DEL, ec);
ec->already_unparented = EINA_TRUE;
CONFIG_VERSION_UPDATE_INFO(19);
/* set (400, 25) as the default values of repeat delay, rate */
- e_config->keyboard.repeat_delay = 400;
- e_config->keyboard.repeat_rate = 25;
+ atomic_store(&e_config->keyboard.repeat_delay, 400);
+ atomic_store(&e_config->keyboard.repeat_rate, 25);
}
}
e_devicemgr->dconfig = dconfig;
g_rec_mutex_init(&e_devicemgr->device_list_mutex);
- g_rec_mutex_init(&e_devicemgr->last_device_kbd_mutex);
res = e_devicemgr_wl_init();
EINA_SAFETY_ON_FALSE_GOTO(res, wl_failed);
e_devicemgr_shutdown(void)
{
g_rec_mutex_clear(&e_devicemgr->device_list_mutex);
- g_rec_mutex_clear(&e_devicemgr->last_device_kbd_mutex);
eina_log_domain_unregister(_devicemgr_log_dom);
_devicemgr_log_dom = -1;
int max_touch_count;
GRecMutex device_list_mutex;
- GRecMutex last_device_kbd_mutex;
struct
{
}
}
- g_rec_mutex_lock(&e_devicemgr->last_device_kbd_mutex);
- if (!e_devicemgr->last_device_kbd && dev->clas == ECORE_DEVICE_CLASS_KEYBOARD)
- e_devicemgr->last_device_kbd = dev;
-
- g_rec_mutex_unlock(&e_devicemgr->last_device_kbd_mutex);
+ E_Devicemgr_Input_Device *last_device_kbd = atomic_load(&e_devicemgr->last_device_kbd);
+ if (!last_device_kbd && dev->clas == ECORE_DEVICE_CLASS_KEYBOARD)
+ atomic_store(&e_devicemgr->last_device_kbd, dev);
e_devicemgr_inputgen_device_ready_send(dev);
e_devicemgr_wl_device_add(dev);
_e_devicemgr_input_device_del(const char *name, const char *identifier, const char *seatname, Ecore_Device_Class clas, Ecore_Device_Subclass subclas)
{
E_Devicemgr_Input_Device *dev = NULL;
+ E_Devicemgr_Input_Device *last_device_kbd = NULL;
Eina_List *l;
EINA_SAFETY_ON_NULL_RETURN(name);
if (e_devicemgr->last_device_touch == dev)
e_devicemgr->last_device_touch = NULL;
- if (e_devicemgr->last_device_kbd == dev)
- {
- g_rec_mutex_lock(&e_devicemgr->last_device_kbd_mutex);
- e_devicemgr->last_device_kbd = NULL;
- g_rec_mutex_unlock(&e_devicemgr->last_device_kbd_mutex);
- }
+ last_device_kbd = atomic_load(&e_devicemgr->last_device_kbd);
+
+ if (last_device_kbd == dev)
+ atomic_store(&e_devicemgr->last_device_kbd, NULL);
E_FREE(dev);
}
EINA_SAFETY_ON_NULL_RETURN_VAL(log_fp, reply);
fprintf(log_fp, "\tkeyboard repeat info\n");
- g_mutex_lock(&e_comp_wl->kbd.repeat_rate_mutex);
- g_mutex_lock(&e_comp_wl->kbd.repeat_delay_mutex);
fprintf(log_fp, "\t\trate: %d (ms), delay: %d (ms)\n", e_comp_wl->kbd.repeat_rate, e_comp_wl->kbd.repeat_delay);
- g_mutex_unlock(&e_comp_wl->kbd.repeat_delay_mutex);
- g_mutex_unlock(&e_comp_wl->kbd.repeat_rate_mutex);
fclose(log_fp);
log_fp = NULL;
}
else
{
- g_mutex_lock(&e_comp_wl->kbd.repeat_delay_mutex);
if (delay <= 0) delay = e_comp_wl->kbd.repeat_delay;
- g_mutex_unlock(&e_comp_wl->kbd.repeat_delay_mutex);
-
- g_mutex_lock(&e_comp_wl->kbd.repeat_rate_mutex);
if (rate <= 0) rate = e_comp_wl->kbd.repeat_rate;
- g_mutex_unlock(&e_comp_wl->kbd.repeat_rate_mutex);
e_comp_wl_input_keyboard_repeat_set(delay, rate);
}
unsigned int blocked;
void *blocked_client;
unsigned int server_blocked;
- GRecMutex blocked_client_mutex;
};
EINTERN int e_input_init(Ecore_Evas *ee);
dev->seat = eina_stringshare_add("seat0");
dev->fd_hash = eina_hash_string_superfast_new(NULL);
- g_rec_mutex_init(&dev->blocked_client_mutex);
-
/* try to create xkb context */
if (!(dev->xkb_ctx = _e_input_device_cached_context_get(0)))
{
/* check for valid device */
EINA_SAFETY_ON_NULL_RETURN_VAL(dev, EINA_FALSE);
- g_rec_mutex_clear(&dev->blocked_client_mutex);
-
_e_input_device_remove_list(dev);
e_input_device_destroy(dev);
}
dev->blocked |= type;
- g_rec_mutex_lock(&dev->blocked_client_mutex);
- dev->blocked_client = client;
- g_rec_mutex_unlock(&dev->blocked_client_mutex);
+ atomic_store(&dev->blocked_client, client);
}
else if (client == E_INPUT_REQUEST_SERVER)
{
{
EINA_LIST_FOREACH(e_input_seat_evdev_list_get(seat), l2, edev)
{
- g_rec_mutex_lock(&edev->touch.blocked_mutex);
- edev->touch.blocked = EINA_TRUE;
- g_rec_mutex_unlock(&edev->touch.blocked_mutex);
+ atomic_store(&edev->touch.blocked, EINA_TRUE);
}
}
}
E_Input_Seat *seat = NULL;
E_Input_Evdev *edev = NULL;
Eina_List *l = NULL, *l2 = NULL;
+ unsigned int raw_pressed = 0;
EINA_SAFETY_ON_NULL_RETURN_VAL(dev, EINA_FALSE);
{
EINA_LIST_FOREACH(e_input_seat_evdev_list_get(seat), l2, edev)
{
- g_rec_mutex_lock(&edev->touch.raw_pressed_mutex);
-
- if (edev->touch.raw_pressed == 0x0)
+ raw_pressed = atomic_load(&edev->touch.raw_pressed);
+ if (raw_pressed == 0x0)
{
- g_rec_mutex_lock(&edev->touch.blocked_mutex);
- edev->touch.blocked = EINA_FALSE;
- g_rec_mutex_unlock(&edev->touch.blocked_mutex);
+ atomic_store(&edev->touch.blocked, EINA_FALSE);
}
-
- g_rec_mutex_unlock(&edev->touch.raw_pressed_mutex);
}
}
}
else
{
dev->blocked = 0x0;
- g_rec_mutex_lock(&dev->blocked_client_mutex);
- dev->blocked_client = NULL;
- g_rec_mutex_unlock(&dev->blocked_client_mutex);
+ atomic_store(&dev->blocked_client, NULL);
}
return EINA_TRUE;
if ((edev->seat->dev->blocked & E_INPUT_SEAT_KEYBOARD) ||
(edev->seat->dev->server_blocked & E_INPUT_SEAT_KEYBOARD))
{
- g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
+ void *blocked_client = atomic_load(&edev->seat->dev->blocked_client);
ELOGF("Key", "Press (keycode: %d, device: %s) is blocked by %p, server: 0x%x", NULL,
- code, device_name, edev->seat->dev->blocked_client,
+ code, device_name, blocked_client,
edev->seat->dev->server_blocked);
- g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
return;
}
}
if (!dup_found)
{
- g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
+ void *blocked_client = atomic_load(&edev->seat->dev->blocked_client);
ELOGF("Key", "Release (keycode: %d, device: %s) is blocked by %p", NULL,
- code, device_name, edev->seat->dev->blocked_client);
- g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
+ code, device_name, blocked_client);
return;
}
}
if (button == 3) button = 2;
else if (button == 2) button = 3;
+ void *blocked_client = atomic_load(&edev->seat->dev->blocked_client);
+
if (state)
{
if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
(edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
{
- g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
+
ELOGF("Mouse", "Button Press (btn: %d, device: %s) is blocked by %p, server: 0x%x", NULL,
- button, ecore_device_name_get(ecore_dev), edev->seat->dev->blocked_client,
+ button, ecore_device_name_get(ecore_dev), blocked_client,
edev->seat->dev->server_blocked);
- g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
goto end;
}
else
{
if (!(edev->mouse.pressed_button & (1 << button)))
{
- g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
ELOGF("Mouse", "Button Release (btn: %d, device: %s) is blocked by %p, server: 0x%x", NULL,
- button, ecore_device_name_get(ecore_dev), edev->seat->dev->blocked_client,
+ button, ecore_device_name_get(ecore_dev), blocked_client,
edev->seat->dev->server_blocked);
- g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
goto end;
}
edev->mouse.pressed_button &= ~(1 << button);
if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
(edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
{
- g_mutex_lock(&edev->seat->dev->blocked_client_mutex);
+ void *blocked_client = atomic_load(&edev->seat->dev->blocked_client);
if (detent_data)
ELOGF("Mouse", "Detent (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
- direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
+ direction, z, blocked_client, edev->seat->dev->server_blocked);
else
ELOGF("Mouse", "Wheel (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
- direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
+ direction, z, blocked_client, edev->seat->dev->server_blocked);
- g_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
goto end;
}
if ((edev->seat->dev->blocked & E_INPUT_SEAT_POINTER) ||
(edev->seat->dev->server_blocked & E_INPUT_SEAT_POINTER))
{
- g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
+ void *blocked_client = atomic_load(&edev->seat->dev->blocked_client);
if (detent_data)
ELOGF("Mouse", "Detent (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
- direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
+ direction, z, blocked_client, edev->seat->dev->server_blocked);
else
ELOGF("Mouse", "Wheel (direction: %d, value: %d) is blocked by %p, server: 0x%x", NULL,
- direction, z, edev->seat->dev->blocked_client, edev->seat->dev->server_blocked);
+ direction, z, blocked_client, edev->seat->dev->server_blocked);
- g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
goto end;
}
if (comp_conf && comp_conf->input_log_enable)
ELOGF("Touch", "Down (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
- g_rec_mutex_lock(&edev->touch.raw_pressed_mutex);
- edev->touch.raw_pressed |= (1 << edev->mt_slot);
- g_rec_mutex_unlock(&edev->touch.raw_pressed_mutex);
+ atomic_fetch_or(&edev->touch.raw_pressed, (1 << edev->mt_slot));
- g_rec_mutex_lock(&edev->touch.blocked_mutex);
if (edev->touch.blocked)
{
- g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
+ void *blocked_client = atomic_load(&edev->seat->dev->blocked_client);
ELOGF("Touch", "Down (id: %d, x: %d, y: %d) is blocked by %p, server: 0x%x", NULL,
- edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, edev->seat->dev->blocked_client,
+ edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, blocked_client,
edev->seat->dev->server_blocked);
- g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
- g_rec_mutex_unlock(&edev->touch.blocked_mutex);
return;
}
- g_rec_mutex_unlock(&edev->touch.blocked_mutex);
-
_device_handle_touch_motion_send(edev, event);
_device_handle_touch_event_send(edev, event, ECORE_EVENT_MOUSE_BUTTON_DOWN);
}
if (!(edev->touch.pressed & (1 << edev->mt_slot)))
{
- g_rec_mutex_lock(&edev->touch.blocked_mutex);
if (edev->touch.blocked)
{
- g_rec_mutex_unlock(&edev->touch.blocked_mutex);
return;
}
- g_rec_mutex_unlock(&edev->touch.blocked_mutex);
}
_device_handle_touch_motion_send(edev, event);
if (comp_conf && comp_conf->input_log_enable)
ELOGF("Touch", "Up (id: %d, x: %d, y: %d)", NULL, edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy);
- g_rec_mutex_lock(&edev->touch.raw_pressed_mutex);
- edev->touch.raw_pressed &= ~(1 << edev->mt_slot);
- g_rec_mutex_unlock(&edev->touch.raw_pressed_mutex);
+ atomic_fetch_and(&edev->touch.raw_pressed, ~(1 << edev->mt_slot));
- g_rec_mutex_lock(&edev->touch.blocked_mutex);
if (edev->touch.blocked)
{
if (!(edev->touch.pressed & (1 << edev->mt_slot)))
{
- g_rec_mutex_lock(&edev->seat->dev->blocked_client_mutex);
+ void *blocked_client = atomic_load(&edev->seat->dev->blocked_client);
ELOGF("Touch", "Up (id: %d, x: %d, y: %d) is blocked by %p, server(0x%x)", NULL,
- edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, edev->seat->dev->blocked_client,
+ edev->mt_slot, edev->seat->ptr.ix, edev->seat->ptr.iy, blocked_client,
edev->seat->dev->server_blocked);
- g_rec_mutex_unlock(&edev->seat->dev->blocked_client_mutex);
- g_rec_mutex_lock(&edev->touch.raw_pressed_mutex);
if (edev->touch.raw_pressed == 0x0)
{
edev->touch.blocked = EINA_FALSE;
}
- g_rec_mutex_unlock(&edev->touch.raw_pressed_mutex);
- g_rec_mutex_unlock(&edev->touch.blocked_mutex);
return;
}
}
- g_rec_mutex_unlock(&edev->touch.blocked_mutex);
_device_handle_touch_event_send(edev, event, ECORE_EVENT_MOUSE_BUTTON_UP);
}
edev->device = device;
edev->path = eina_stringshare_printf("%s/%s", e_input_base_dir_get(), libinput_device_get_sysname(device));
- g_rec_mutex_init(&edev->touch.raw_pressed_mutex);
- g_rec_mutex_init(&edev->touch.blocked_mutex);
-
if (e_input)
g_rec_mutex_lock(&e_input->libinput_mutex);
free(edev->touch.coords);
edev->touch.coords = NULL;
}
- g_rec_mutex_clear(&edev->touch.raw_pressed_mutex);
- g_rec_mutex_clear(&edev->touch.blocked_mutex);
eina_stringshare_del(edev->output_name);
ecore_thread_main_loop_end();
E_Input_Coord *coords;
unsigned int pressed;
- unsigned int raw_pressed;
- Eina_Bool blocked;
- GRecMutex raw_pressed_mutex;
- GRecMutex blocked_mutex;
+ atomic_uint raw_pressed;
+ atomic_bool blocked;
} touch;
const char *output_name;