[v16,7/9] eal: implement functions for mutex management
Checks
Commit Message
From: Narcisa Vasile <navasile@microsoft.com>
Add functions for mutex init, destroy, lock, unlock, trylock.
Add RTE_STATIC_MUTEX macro to replace static initialization
of mutexes.
Windows does not have a static initializer.
Initialization is only done through InitializeCriticalSection().
The RTE_STATIC_MUTEX calls into the rte_thread_mutex_init()
function that performs the actual mutex initialization.
Signed-off-by: Narcisa Vasile <navasile@microsoft.com>
---
lib/eal/common/rte_thread.c | 69 ++++++++++++++++++++++
lib/eal/include/rte_thread.h | 108 +++++++++++++++++++++++++++++++++++
lib/eal/version.map | 5 ++
lib/eal/windows/rte_thread.c | 64 +++++++++++++++++++++
4 files changed, 246 insertions(+)
Comments
09/10/2021 09:41, Narcisa Ana Maria Vasile:
> From: Narcisa Vasile <navasile@microsoft.com>
>
> Add functions for mutex init, destroy, lock, unlock, trylock.
>
> Add RTE_STATIC_MUTEX macro to replace static initialization
> of mutexes.
> Windows does not have a static initializer.
> Initialization is only done through InitializeCriticalSection().
>
> The RTE_STATIC_MUTEX calls into the rte_thread_mutex_init()
> function that performs the actual mutex initialization.
[...]
> --- a/lib/eal/include/rte_thread.h
> +++ b/lib/eal/include/rte_thread.h
> +#define RTE_DECLARE_MUTEX(private_lock) rte_thread_mutex private_lock
> +
> +#define RTE_DEFINE_MUTEX(private_lock)\
> +RTE_INIT(__rte_ ## private_lock ## _init)\
> +{\
> + RTE_VERIFY(rte_thread_mutex_init(&private_lock) == 0);\
> +}
> +
> +#define RTE_STATIC_MUTEX(private_lock)\
> +static RTE_DECLARE_MUTEX(private_lock);\
> +RTE_DEFINE_MUTEX(private_lock)
This is not truly static.
It is a wrapper to init the mutex in the constructor.
Should we rename?
On Tue, Oct 12, 2021 at 06:28:56PM +0200, Thomas Monjalon wrote:
> 09/10/2021 09:41, Narcisa Ana Maria Vasile:
> > From: Narcisa Vasile <navasile@microsoft.com>
> >
> > Add functions for mutex init, destroy, lock, unlock, trylock.
> >
> > Add RTE_STATIC_MUTEX macro to replace static initialization
> > of mutexes.
> > Windows does not have a static initializer.
> > Initialization is only done through InitializeCriticalSection().
> >
> > The RTE_STATIC_MUTEX calls into the rte_thread_mutex_init()
> > function that performs the actual mutex initialization.
> [...]
> > --- a/lib/eal/include/rte_thread.h
> > +++ b/lib/eal/include/rte_thread.h
> > +#define RTE_DECLARE_MUTEX(private_lock) rte_thread_mutex private_lock
> > +
> > +#define RTE_DEFINE_MUTEX(private_lock)\
> > +RTE_INIT(__rte_ ## private_lock ## _init)\
> > +{\
> > + RTE_VERIFY(rte_thread_mutex_init(&private_lock) == 0);\
> > +}
> > +
> > +#define RTE_STATIC_MUTEX(private_lock)\
> > +static RTE_DECLARE_MUTEX(private_lock);\
> > +RTE_DEFINE_MUTEX(private_lock)
>
> This is not truly static.
> It is a wrapper to init the mutex in the constructor.
> Should we rename?
>
Agreed, I'll rename to RTE_MUTEX_INIT or something like this.
Thanks!
@@ -295,6 +295,75 @@ rte_thread_detach(rte_thread_t thread_id)
return pthread_detach((pthread_t)thread_id.opaque_id);
}
+int
+rte_thread_mutex_init(rte_thread_mutex *mutex)
+{
+ int ret = 0;
+ pthread_mutex_t *m = NULL;
+
+ RTE_VERIFY(mutex != NULL);
+
+ m = calloc(1, sizeof(*m));
+ if (m == NULL) {
+ RTE_LOG(DEBUG, EAL, "Unable to initialize mutex. Insufficient memory!\n");
+ ret = ENOMEM;
+ goto cleanup;
+ }
+
+ ret = pthread_mutex_init(m, NULL);
+ if (ret != 0) {
+ RTE_LOG(DEBUG, EAL, "Failed to init mutex. ret = %d\n", ret);
+ goto cleanup;
+ }
+
+ mutex->mutex_id = m;
+ m = NULL;
+
+cleanup:
+ free(m);
+ return ret;
+}
+
+int
+rte_thread_mutex_lock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ return pthread_mutex_lock((pthread_mutex_t *)mutex->mutex_id);
+}
+
+int
+rte_thread_mutex_unlock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ return pthread_mutex_unlock((pthread_mutex_t *)mutex->mutex_id);
+}
+
+int
+rte_thread_mutex_try_lock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ return pthread_mutex_trylock((pthread_mutex_t *)mutex->mutex_id);
+}
+
+int
+rte_thread_mutex_destroy(rte_thread_mutex *mutex)
+{
+ int ret = 0;
+ RTE_VERIFY(mutex != NULL);
+
+ ret = pthread_mutex_destroy((pthread_mutex_t *)mutex->mutex_id);
+ if (ret != 0)
+ RTE_LOG(DEBUG, EAL, "Unable to destroy mutex, ret = %d\n", ret);
+
+ free(mutex->mutex_id);
+ mutex->mutex_id = NULL;
+
+ return ret;
+}
+
int
rte_thread_key_create(rte_thread_key *key, void (*destructor)(void *))
{
@@ -54,6 +54,26 @@ typedef struct {
#endif /* RTE_HAS_CPUSET */
+#define RTE_DECLARE_MUTEX(private_lock) rte_thread_mutex private_lock
+
+#define RTE_DEFINE_MUTEX(private_lock)\
+RTE_INIT(__rte_ ## private_lock ## _init)\
+{\
+ RTE_VERIFY(rte_thread_mutex_init(&private_lock) == 0);\
+}
+
+#define RTE_STATIC_MUTEX(private_lock)\
+static RTE_DECLARE_MUTEX(private_lock);\
+RTE_DEFINE_MUTEX(private_lock)
+
+
+/**
+ * Thread mutex representation.
+ */
+typedef struct rte_thread_mutex_tag {
+ void *mutex_id; /**< mutex identifier */
+} rte_thread_mutex;
+
/**
* TLS key type, an opaque pointer.
*/
@@ -266,6 +286,28 @@ int rte_thread_join(rte_thread_t thread_id, unsigned long *value_ptr);
__rte_experimental
int rte_thread_detach(rte_thread_t thread_id);
+/**
+ * Set core affinity of the current thread.
+ * Support both EAL and non-EAL thread and update TLS.
+ *
+ * @param cpusetp
+ * Pointer to CPU affinity to set.
+ *
+ * @return
+ * On success, return 0; otherwise return -1;
+ */
+int rte_thread_set_affinity(rte_cpuset_t *cpusetp);
+
+/**
+ * Get core affinity of the current thread.
+ *
+ * @param cpusetp
+ * Pointer to CPU affinity of current thread.
+ * It presumes input is not NULL, otherwise it causes panic.
+ *
+ */
+void rte_thread_get_affinity(rte_cpuset_t *cpusetp);
+
#endif /* RTE_HAS_CPUSET */
/**
@@ -302,6 +344,72 @@ __rte_experimental
int rte_thread_set_priority(rte_thread_t thread_id,
enum rte_thread_priority priority);
+/**
+ * Initializes a mutex.
+ *
+ * @param mutex
+ * The mutex to be initialized.
+ *
+ * @return
+ * On success, return 0.
+ * On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_init(rte_thread_mutex *mutex);
+
+/**
+ * Locks a mutex.
+ *
+ * @param mutex
+ * The mutex to be locked.
+ *
+ * @return
+ * On success, return 0.
+ * On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_lock(rte_thread_mutex *mutex);
+
+/**
+ * Unlocks a mutex.
+ *
+ * @param mutex
+ * The mutex to be unlocked.
+ *
+ * @return
+ * On success, return 0.
+ * On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_unlock(rte_thread_mutex *mutex);
+
+/**
+ * Tries to lock a mutex.If the mutex is already held by a different thread,
+ * the function returns without blocking.
+ *
+ * @param mutex
+ * The mutex that will be acquired, if not already locked.
+ *
+ * @return
+ * On success, if the mutex is acquired, return 0.
+ * On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_try_lock(rte_thread_mutex *mutex);
+
+/**
+ * Releases all resources associated with a mutex.
+ *
+ * @param mutex
+ * The mutex to be uninitialized.
+ *
+ * @return
+ * On success, return 0.
+ * On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_destroy(rte_thread_mutex *mutex);
+
/**
* Create a TLS data key visible to all threads in the process.
* the created key is later used to get/set a value.
@@ -434,6 +434,11 @@ EXPERIMENTAL {
rte_thread_create;
rte_thread_join;
rte_thread_detach;
+ rte_thread_mutex_init;
+ rte_thread_mutex_lock;
+ rte_thread_mutex_unlock;
+ rte_thread_mutex_try_lock;
+ rte_thread_mutex_destroy;
};
INTERNAL {
@@ -504,6 +504,70 @@ rte_thread_detach(rte_thread_t thread_id)
return 0;
}
+int
+rte_thread_mutex_init(rte_thread_mutex *mutex)
+{
+ int ret = 0;
+ CRITICAL_SECTION *m = NULL;
+
+ RTE_VERIFY(mutex != NULL);
+
+ m = calloc(1, sizeof(*m));
+ if (m == NULL) {
+ RTE_LOG(DEBUG, EAL, "Unable to initialize mutex. Insufficient memory!\n");
+ ret = ENOMEM;
+ goto cleanup;
+ }
+
+ InitializeCriticalSection(m);
+ mutex->mutex_id = m;
+ m = NULL;
+
+cleanup:
+ return ret;
+}
+
+int
+rte_thread_mutex_lock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ EnterCriticalSection(mutex->mutex_id);
+ return 0;
+}
+
+int
+rte_thread_mutex_unlock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ LeaveCriticalSection(mutex->mutex_id);
+ return 0;
+}
+
+int
+rte_thread_mutex_try_lock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ if (TryEnterCriticalSection(mutex->mutex_id) != 0)
+ return 0;
+
+ return EBUSY;
+}
+
+int
+rte_thread_mutex_destroy(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ DeleteCriticalSection(mutex->mutex_id);
+ free(mutex->mutex_id);
+ mutex->mutex_id = NULL;
+
+ return 0;
+}
+
int
rte_thread_key_create(rte_thread_key *key,
__rte_unused void (*destructor)(void *))