e_input: Use c11 atomic instead of mutex

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>

diff --git a/src/bin/e.h b/src/bin/e.h
index e58cd80..5b8825a 100644 (file)
--- a/src/bin/e.h
+++ b/src/bin/e.h
@@ -84,6 +84,13 @@ void *alloca (size_t);
 # 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

diff --git a/src/bin/e_comp_wl.c b/src/bin/e_comp_wl.c
index 600a649..60f79ed 100644 (file)
--- a/src/bin/e_comp_wl.c
+++ b/src/bin/e_comp_wl.c
@@ -794,9 +794,7 @@ _e_comp_wl_device_last_device_get(Ecore_Device_Class dev_class)
       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;
@@ -815,9 +813,7 @@ _e_comp_wl_device_last_device_set(Ecore_Device_Class dev_class, E_Devicemgr_Inpu
          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;
@@ -837,9 +833,7 @@ _e_comp_wl_device_client_last_device_get(E_Client *ec, Ecore_Device_Class dev_cl
       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;
@@ -858,9 +852,7 @@ _e_comp_wl_device_client_last_device_set(E_Client *ec, Ecore_Device_Class dev_cl
          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;

diff --git a/src/bin/e_comp_wl.h b/src/bin/e_comp_wl.h
index dc0baca..927d11f 100644 (file)
--- a/src/bin/e_comp_wl.h
+++ b/src/bin/e_comp_wl.h
@@ -224,10 +224,9 @@ struct _E_Comp_Wl_Data
         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 */
@@ -531,7 +530,6 @@ struct _E_Comp_Wl_Client_Data
 
    Eina_Bool wtz_surface_assigned;
    struct wl_list pointer_constraints;
-   GRecMutex last_device_kbd_mutex;
    GMutex surface_mutex;
 
    struct wl_signal state_commit_signal;

diff --git a/src/bin/e_comp_wl_input.c b/src/bin/e_comp_wl_input.c
index 5d031c5..2efd0c6 100644 (file)
--- a/src/bin/e_comp_wl_input.c
+++ b/src/bin/e_comp_wl_input.c
@@ -327,6 +327,9 @@ e_comp_wl_input_keyboard_enter_send(E_Client *ec)
    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;
 
@@ -344,22 +347,28 @@ e_comp_wl_input_keyboard_enter_send(E_Client *ec)
 
    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
@@ -390,11 +399,7 @@ _e_comp_wl_input_cb_keyboard_get(struct wl_client *client, struct wl_resource *r
    /* 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 */
@@ -1397,7 +1402,6 @@ e_comp_wl_input_init(void)
    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);
@@ -1407,21 +1411,19 @@ e_comp_wl_input_init(void)
    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 =
@@ -1505,8 +1507,6 @@ e_comp_wl_input_shutdown(void)
         _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);
@@ -1620,31 +1620,37 @@ e_comp_wl_input_keyboard_modifiers_serialize(void)
    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;
 }
@@ -1667,7 +1673,6 @@ e_comp_wl_input_keyboard_modifiers_update(void)
    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,
@@ -1676,7 +1681,6 @@ e_comp_wl_input_keyboard_modifiers_update(void)
                                 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
@@ -1694,8 +1698,7 @@ e_comp_wl_input_keyboard_state_update(uint32_t keycode, Eina_Bool pressed)
    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);
 
@@ -2011,25 +2014,17 @@ e_comp_wl_input_keyboard_repeat_set(int delay, int rate)
 
    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);
 }
 

diff --git a/src/bin/e_compositor.c b/src/bin/e_compositor.c
index 98b4bc7..fc7f995 100644 (file)
--- a/src/bin/e_compositor.c
+++ b/src/bin/e_compositor.c
@@ -452,7 +452,6 @@ _e_compositor_cb_new_client(void *data EINA_UNUSED, E_Client *ec)
 
    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:
@@ -1009,8 +1008,6 @@ _e_surface_cb_client_del(void *data, E_Client *ec)
 
    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;

diff --git a/src/bin/e_config.c b/src/bin/e_config.c
index 614bc32..cbd932a 100644 (file)
--- a/src/bin/e_config.c
+++ b/src/bin/e_config.c
@@ -454,8 +454,8 @@ e_config_load(void)
              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);
           }
      }
 

diff --git a/src/bin/e_devicemgr.c b/src/bin/e_devicemgr.c
index fecc88c..c613d07 100644 (file)
--- a/src/bin/e_devicemgr.c
+++ b/src/bin/e_devicemgr.c
@@ -131,7 +131,6 @@ e_devicemgr_init(void)
    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);
@@ -170,7 +169,6 @@ EINTERN int
 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;

diff --git a/src/bin/e_devicemgr.h b/src/bin/e_devicemgr.h
index 5edbc95..42a3b47 100644 (file)
--- a/src/bin/e_devicemgr.h
+++ b/src/bin/e_devicemgr.h
@@ -87,7 +87,6 @@ struct _E_Devicemgr
 
    int max_touch_count;
    GRecMutex device_list_mutex;
-   GRecMutex last_device_kbd_mutex;
 
    struct
    {

diff --git a/src/bin/e_devicemgr_input.c b/src/bin/e_devicemgr_input.c
index 62512e9..2c20562 100644 (file)
--- a/src/bin/e_devicemgr_input.c
+++ b/src/bin/e_devicemgr_input.c
@@ -258,11 +258,9 @@ _e_devicemgr_input_device_add(const char *name, const char *identifier, const ch
           }
      }
 
-   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);
@@ -274,6 +272,7 @@ static void
 _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);
@@ -312,12 +311,10 @@ _e_devicemgr_input_device_del(const char *name, const char *identifier, const ch
    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);
 }

diff --git a/src/bin/e_info_server.c b/src/bin/e_info_server.c
index b7af808..5f3b25b 100644 (file)
--- a/src/bin/e_info_server.c
+++ b/src/bin/e_info_server.c
@@ -6695,23 +6695,14 @@ _e_info_server_cb_key_repeat(const Eldbus_Service_Interface *iface EINA_UNUSED,
         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);
      }

diff --git a/src/bin/e_input.h b/src/bin/e_input.h
index 08b5282..9a046db 100644 (file)
--- a/src/bin/e_input.h
+++ b/src/bin/e_input.h
@@ -93,7 +93,6 @@ struct _E_Input_Device
    unsigned int blocked;
    void *blocked_client;
    unsigned int server_blocked;
-   GRecMutex blocked_client_mutex;
 };
 
 EINTERN int e_input_init(Ecore_Evas *ee);

diff --git a/src/bin/e_input_device.c b/src/bin/e_input_device.c
index 09d90fe..46f536f 100644 (file)
--- a/src/bin/e_input_device.c
+++ b/src/bin/e_input_device.c
@@ -236,8 +236,6 @@ e_input_device_open(void)
    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)))
      {
@@ -270,8 +268,6 @@ e_input_device_close(E_Input_Device *dev)
    /* 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);
 
@@ -1307,9 +1303,7 @@ e_input_device_block(E_Input_Device *dev, unsigned int type, void *client)
           }
 
         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)
      {
@@ -1322,9 +1316,7 @@ e_input_device_block(E_Input_Device *dev, unsigned int type, void *client)
           {
              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);
                }
           }
      }
@@ -1338,6 +1330,7 @@ e_input_device_unblock(E_Input_Device *dev, void *client)
    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);
 
@@ -1354,16 +1347,11 @@ e_input_device_unblock(E_Input_Device *dev, void *client)
           {
              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);
                }
           }
      }
@@ -1375,9 +1363,7 @@ e_input_device_unblock(E_Input_Device *dev, void *client)
    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;

diff --git a/src/bin/e_input_evdev.c b/src/bin/e_input_evdev.c
index f6ab341..bc14bdc 100644 (file)
--- a/src/bin/e_input_evdev.c
+++ b/src/bin/e_input_evdev.c
@@ -629,11 +629,10 @@ _device_handle_key(struct libinput_device *device, struct libinput_event_keyboar
         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;
           }
 
@@ -674,10 +673,9 @@ _device_handle_key(struct libinput_device *device, struct libinput_event_keyboar
           }
         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;
           }
      }
@@ -1174,16 +1172,17 @@ _device_handle_button(struct libinput_device *device, struct libinput_event_poin
    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
@@ -1195,11 +1194,9 @@ _device_handle_button(struct libinput_device *device, struct libinput_event_poin
      {
         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);
@@ -1409,16 +1406,15 @@ _device_handle_axis(struct libinput_device *device, struct libinput_event_pointe
    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;
      }
 
@@ -1594,15 +1590,14 @@ _device_handle_axis_v120(struct libinput_device *device, struct libinput_event_p
    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;
      }
 
@@ -2015,24 +2010,17 @@ _device_handle_touch_down(struct libinput_device *device, struct libinput_event_
    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);
 }
@@ -2089,13 +2077,10 @@ _device_handle_touch_motion(struct libinput_device *device, struct libinput_even
 
    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);
@@ -2141,33 +2126,25 @@ _device_handle_touch_up(struct libinput_device *device, struct libinput_event_to
    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);
 }
 
@@ -2314,9 +2291,6 @@ _e_input_evdev_device_create(E_Input_Seat *seat, struct libinput_device *device)
    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);
 
@@ -2433,8 +2407,6 @@ _e_input_evdev_device_destroy(E_Input_Evdev *edev)
         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();

diff --git a/src/bin/e_input_private.h b/src/bin/e_input_private.h
index be413a1..79100df 100644 (file)
--- a/src/bin/e_input_private.h
+++ b/src/bin/e_input_private.h
@@ -155,10 +155,8 @@ struct _E_Input_Evdev
 
         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;