Rename jl_mutex_func->jl_spin_mutex_func

Author: pchintalapudi

src/gc-heap-snapshot.cpp

@@ -135,7 +135,7 @@ JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one)
     HeapSnapshot snapshot;
     _add_internal_root(&snapshot);
 
-    jl_mutex_lock(&heapsnapshot_lock);
+    jl_spin_mutex_lock(&heapsnapshot_lock);
 
     // Enable snapshotting
     g_snapshot = &snapshot;
@@ -148,7 +148,7 @@ JL_DLLEXPORT void jl_gc_take_heap_snapshot(ios_t *stream, char all_one)
     gc_heap_snapshot_enabled = false;
     g_snapshot = nullptr;
 
-    jl_mutex_unlock(&heapsnapshot_lock);
+    jl_spin_mutex_unlock(&heapsnapshot_lock);
 
     // When we return, the snapshot is full
     // Dump the snapshot

src/jl_uv.c

@@ -119,7 +119,7 @@ _Atomic(int) jl_uv_n_waiters = 0;
 
 void JL_UV_LOCK(void)
 {
-    if (jl_mutex_trylock(&jl_uv_mutex)) {
+    if (jl_spin_mutex_trylock(&jl_uv_mutex)) {
     }
     else {
         jl_atomic_fetch_add_relaxed(&jl_uv_n_waiters, 1);
@@ -273,7 +273,7 @@ JL_DLLEXPORT int jl_process_events(void)
     uv_loop_t *loop = jl_io_loop;
     jl_gc_safepoint_(ct->ptls);
     if (loop && (jl_atomic_load_relaxed(&_threadedregion) || jl_atomic_load_relaxed(&ct->tid) == 0)) {
-        if (jl_atomic_load_relaxed(&jl_uv_n_waiters) == 0 && jl_mutex_trylock(&jl_uv_mutex)) {
+        if (jl_atomic_load_relaxed(&jl_uv_n_waiters) == 0 && jl_spin_mutex_trylock(&jl_uv_mutex)) {
             JL_PROBE_RT_START_PROCESS_EVENTS(ct);
             loop->stop_flag = 0;
             uv_ref((uv_handle_t*)&signal_async); // force the loop alive

src/julia_locks.h

@@ -11,32 +11,32 @@ extern "C" {
 
 // Lock acquire and release primitives
 
-// JL_LOCK and jl_mutex_lock are GC safe points, use uv_mutex_t if that is not desired.
+// JL_LOCK and jl_spin_mutex_lock are GC safe points, use uv_mutex_t if that is not desired.
 // Always use JL_LOCK unless no one holding the lock can trigger a GC or GC
 // safepoint. uv_mutex_t should only be needed for GC internal locks.
 // The JL_LOCK* and JL_UNLOCK* macros are no-op for non-threading build
 // while the jl_mutex_* functions are always locking and unlocking the locks.
 
-JL_DLLEXPORT void _jl_mutex_init(jl_spin_mutex_t *lock, const char *name) JL_NOTSAFEPOINT;
-JL_DLLEXPORT void _jl_mutex_wait(jl_task_t *self, jl_spin_mutex_t *lock, int safepoint);
-JL_DLLEXPORT void _jl_mutex_lock(jl_task_t *self, jl_spin_mutex_t *lock);
-JL_DLLEXPORT int _jl_mutex_trylock_nogc(jl_task_t *self, jl_spin_mutex_t *lock) JL_NOTSAFEPOINT;
-JL_DLLEXPORT int _jl_mutex_trylock(jl_task_t *self, jl_spin_mutex_t *lock);
-JL_DLLEXPORT void _jl_mutex_unlock(jl_task_t *self, jl_spin_mutex_t *lock);
-JL_DLLEXPORT void _jl_mutex_unlock_nogc(jl_spin_mutex_t *lock) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void _jl_spin_mutex_init(jl_spin_mutex_t *lock, const char *name) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void _jl_spin_mutex_wait(jl_task_t *self, jl_spin_mutex_t *lock, int safepoint);
+JL_DLLEXPORT void _jl_spin_mutex_lock(jl_task_t *self, jl_spin_mutex_t *lock);
+JL_DLLEXPORT int _jl_spin_mutex_trylock_nogc(jl_task_t *self, jl_spin_mutex_t *lock) JL_NOTSAFEPOINT;
+JL_DLLEXPORT int _jl_spin_mutex_trylock(jl_task_t *self, jl_spin_mutex_t *lock);
+JL_DLLEXPORT void _jl_spin_mutex_unlock(jl_task_t *self, jl_spin_mutex_t *lock);
+JL_DLLEXPORT void _jl_spin_mutex_unlock_nogc(jl_spin_mutex_t *lock) JL_NOTSAFEPOINT;
 
-static inline void jl_mutex_wait(jl_spin_mutex_t *lock, int safepoint)
+static inline void jl_spin_mutex_wait(jl_spin_mutex_t *lock, int safepoint)
 {
-    _jl_mutex_wait(jl_current_task, lock, safepoint);
+    _jl_spin_mutex_wait(jl_current_task, lock, safepoint);
 }
 
-static inline void jl_mutex_lock_nogc(jl_spin_mutex_t *lock) JL_NOTSAFEPOINT JL_NOTSAFEPOINT_ENTER
+static inline void jl_spin_mutex_lock_nogc(jl_spin_mutex_t *lock) JL_NOTSAFEPOINT JL_NOTSAFEPOINT_ENTER
 {
 #ifndef __clang_gcanalyzer__
     // Hide this body from the analyzer, otherwise it complains that we're calling
     // a non-safepoint from this function. The 0 arguments guarantees that we do
     // not reach the safepoint, but the analyzer can't figure that out
-    jl_mutex_wait(lock, 0);
+    jl_spin_mutex_wait(lock, 0);
 #endif
 }
 
@@ -62,41 +62,41 @@ static inline void jl_mutex_lock_nogc(jl_spin_mutex_t *lock) JL_NOTSAFEPOINT JL_
         }                                       \
     } while (0)
 
-static inline void jl_mutex_lock(jl_spin_mutex_t *lock)
+static inline void jl_spin_mutex_lock(jl_spin_mutex_t *lock)
 {
-    _jl_mutex_lock(jl_current_task, lock);
+    _jl_spin_mutex_lock(jl_current_task, lock);
 }
 
-static inline int jl_mutex_trylock_nogc(jl_spin_mutex_t *lock) JL_NOTSAFEPOINT JL_NOTSAFEPOINT_ENTER
+static inline int jl_spin_mutex_trylock_nogc(jl_spin_mutex_t *lock) JL_NOTSAFEPOINT JL_NOTSAFEPOINT_ENTER
 {
-    return _jl_mutex_trylock_nogc(jl_current_task, lock);
+    return _jl_spin_mutex_trylock_nogc(jl_current_task, lock);
 }
 
-static inline int jl_mutex_trylock(jl_spin_mutex_t *lock)
+static inline int jl_spin_mutex_trylock(jl_spin_mutex_t *lock)
 {
-    return _jl_mutex_trylock(jl_current_task, lock);
+    return _jl_spin_mutex_trylock(jl_current_task, lock);
 }
 
-static inline void jl_mutex_unlock(jl_spin_mutex_t *lock)
+static inline void jl_spin_mutex_unlock(jl_spin_mutex_t *lock)
 {
-    _jl_mutex_unlock(jl_current_task, lock);
+    _jl_spin_mutex_unlock(jl_current_task, lock);
 }
 
-static inline void jl_mutex_unlock_nogc(jl_spin_mutex_t *lock) JL_NOTSAFEPOINT JL_NOTSAFEPOINT_LEAVE
+static inline void jl_spin_mutex_unlock_nogc(jl_spin_mutex_t *lock) JL_NOTSAFEPOINT JL_NOTSAFEPOINT_LEAVE
 {
-    _jl_mutex_unlock_nogc(lock);
+    _jl_spin_mutex_unlock_nogc(lock);
 }
 
-static inline void jl_mutex_init(jl_spin_mutex_t *lock, const char *name) JL_NOTSAFEPOINT
+static inline void jl_spin_mutex_init(jl_spin_mutex_t *lock, const char *name) JL_NOTSAFEPOINT
 {
-    _jl_mutex_init(lock, name);
+    _jl_spin_mutex_init(lock, name);
 }
 
-#define JL_MUTEX_INIT(m, name) jl_mutex_init(m, name)
-#define JL_LOCK(m) jl_mutex_lock(m)
-#define JL_UNLOCK(m) jl_mutex_unlock(m)
-#define JL_LOCK_NOGC(m) jl_mutex_lock_nogc(m)
-#define JL_UNLOCK_NOGC(m) jl_mutex_unlock_nogc(m)
+#define JL_MUTEX_INIT(m, name) _Generic((m), jl_spin_mutex_t*: jl_spin_mutex_init(m, name))
+#define JL_LOCK(m) _Generic((m), jl_spin_mutex_t*: jl_spin_mutex_lock(m))
+#define JL_UNLOCK(m) _Generic((m), jl_spin_mutex_t*: jl_spin_mutex_unlock(m))
+#define JL_LOCK_NOGC(m) _Generic((m), jl_spin_mutex_t*: jl_spin_mutex_lock_nogc(m))
+#define JL_UNLOCK_NOGC(m) _Generic((m), jl_spin_mutex_t*: jl_spin_mutex_unlock_nogc(m))
 
 #ifdef __cplusplus
 }

src/partr.c

@@ -382,7 +382,7 @@ JL_DLLEXPORT jl_task_t *jl_task_get_next(jl_value_t *trypoptask, jl_value_t *q,
             //    the lock as unlocked and thus must win this race here.
             int uvlock = 0;
             if (jl_atomic_load_relaxed(&_threadedregion)) {
-                uvlock = jl_mutex_trylock(&jl_uv_mutex);
+                uvlock = jl_spin_mutex_trylock(&jl_uv_mutex);
             }
             else if (ptls->tid == 0) {
                 uvlock = 1;

src/rtutils.c

@@ -263,7 +263,7 @@ JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh)
     int unlocks = locks->len > eh->locks_len;
     if (unlocks) {
         for (size_t i = locks->len; i > eh->locks_len; i--)
-            jl_mutex_unlock_nogc((jl_spin_mutex_t*)locks->items[i - 1]);
+            jl_spin_mutex_unlock_nogc((jl_spin_mutex_t*)locks->items[i - 1]);
         locks->len = eh->locks_len;
     }
     ct->world_age = eh->world_age;

src/threading.c

@@ -730,14 +730,14 @@ JL_DLLEXPORT void jl_exit_threaded_region(void)
 
 // Profiling stubs
 
-void _jl_mutex_init(jl_spin_mutex_t *lock, const char *name) JL_NOTSAFEPOINT
+void _jl_spin_mutex_init(jl_spin_mutex_t *lock, const char *name) JL_NOTSAFEPOINT
 {
     jl_atomic_store_relaxed(&lock->owner, (jl_task_t*)NULL);
     lock->count = 0;
     jl_profile_lock_init(lock, name);
 }
 
-void _jl_mutex_wait(jl_task_t *self, jl_spin_mutex_t *lock, int safepoint)
+void _jl_spin_mutex_wait(jl_task_t *self, jl_spin_mutex_t *lock, int safepoint)
 {
     jl_task_t *owner = jl_atomic_load_relaxed(&lock->owner);
     if (owner == self) {
@@ -787,14 +787,14 @@ static void jl_lock_frame_pop(jl_task_t *self)
     ptls->locks.len--;
 }
 
-void _jl_mutex_lock(jl_task_t *self, jl_spin_mutex_t *lock)
+void _jl_spin_mutex_lock(jl_task_t *self, jl_spin_mutex_t *lock)
 {
     JL_SIGATOMIC_BEGIN_self();
-    _jl_mutex_wait(self, lock, 1);
+    _jl_spin_mutex_wait(self, lock, 1);
     jl_lock_frame_push(self, lock);
 }
 
-int _jl_mutex_trylock_nogc(jl_task_t *self, jl_spin_mutex_t *lock)
+int _jl_spin_mutex_trylock_nogc(jl_task_t *self, jl_spin_mutex_t *lock)
 {
     jl_task_t *owner = jl_atomic_load_acquire(&lock->owner);
     if (owner == self) {
@@ -808,17 +808,17 @@ int _jl_mutex_trylock_nogc(jl_task_t *self, jl_spin_mutex_t *lock)
     return 0;
 }
 
-int _jl_mutex_trylock(jl_task_t *self, jl_spin_mutex_t *lock)
+int _jl_spin_mutex_trylock(jl_task_t *self, jl_spin_mutex_t *lock)
 {
-    int got = _jl_mutex_trylock_nogc(self, lock);
+    int got = _jl_spin_mutex_trylock_nogc(self, lock);
     if (got) {
         JL_SIGATOMIC_BEGIN_self();
         jl_lock_frame_push(self, lock);
     }
     return got;
 }
 
-void _jl_mutex_unlock_nogc(jl_spin_mutex_t *lock)
+void _jl_spin_mutex_unlock_nogc(jl_spin_mutex_t *lock)
 {
 #ifndef __clang_gcanalyzer__
     assert(jl_atomic_load_relaxed(&lock->owner) == jl_current_task &&
@@ -838,9 +838,9 @@ void _jl_mutex_unlock_nogc(jl_spin_mutex_t *lock)
 #endif
 }
 
-void _jl_mutex_unlock(jl_task_t *self, jl_spin_mutex_t *lock)
+void _jl_spin_mutex_unlock(jl_task_t *self, jl_spin_mutex_t *lock)
 {
-    _jl_mutex_unlock_nogc(lock);
+    _jl_spin_mutex_unlock_nogc(lock);
     jl_lock_frame_pop(self);
     JL_SIGATOMIC_END_self();
     if (jl_atomic_load_relaxed(&jl_gc_have_pending_finalizers)) {