[utils/hp] Remove HazardFreeLocking and HazardFreeContext enums.

[mono.git] / mono / utils / mono-linked-list-set.c

diff --git a/mono/utils/mono-linked-list-set.c b/mono/utils/mono-linked-list-set.c
index 3f34359f2731ae779c1b37a0a52f0068fe0d1db8..a3ce43eb64139c3ca9950a2e3c2d82ccb96e4b09 100644 (file)
--- a/mono/utils/mono-linked-list-set.c
+++ b/mono/utils/mono-linked-list-set.c
@@ -16,8 +16,7 @@
 
 #include <mono/utils/mono-linked-list-set.h>
 
-/*atomics.*/
-#include <mono/io-layer/io-layer.h>
+#include <mono/utils/atomic.h>
 
 static inline gpointer
 mask (gpointer n, uintptr_t bit)
@@ -56,7 +55,7 @@ get_hazardous_pointer_with_mask (gpointer volatile *pp, MonoThreadHazardPointers
 
 /*
 Initialize @list and will use @free_node_func to release memory.
-If @free_node_func is null the caller is responsible for releasing node memory. 
+If @free_node_func is null the caller is responsible for releasing node memory.
 */
 void
 mono_lls_init (MonoLinkedListSet *list, void (*free_node_func)(void *))
@@ -69,11 +68,6 @@ mono_lls_init (MonoLinkedListSet *list, void (*free_node_func)(void *))
 Search @list for element with key @key.
 The nodes next, cur and prev are returned in @hp.
 Returns true if a node with key @key was found.
-This function cannot be called from a signal nor within interrupt context*.
-XXX A variant that works within interrupted is possible if needed.
-
-* interrupt context is when the current thread is reposible for another thread
-been suspended at an arbritary point. This is a limitation of our SMR implementation.
 */
 gboolean
 mono_lls_find (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, uintptr_t key)
@@ -94,12 +88,12 @@ try_again:
         */
        mono_hazard_pointer_set (hp, 2, prev);
 
-       cur = get_hazardous_pointer_with_mask ((gpointer*)prev, hp, 1);
+       cur = (MonoLinkedListSetNode *) get_hazardous_pointer_with_mask ((gpointer*)prev, hp, 1);
 
        while (1) {
                if (cur == NULL)
                        return FALSE;
-               next = get_hazardous_pointer_with_mask ((gpointer*)&cur->next, hp, 0);
+               next = (MonoLinkedListSetNode *) get_hazardous_pointer_with_mask ((gpointer*)&cur->next, hp, 0);
                cur_key = cur->key;
 
                /*
@@ -119,17 +113,17 @@ try_again:
                        prev = &cur->next;
                        mono_hazard_pointer_set (hp, 2, cur);
                } else {
-                       next = mono_lls_pointer_unmask (next);
+                       next = (MonoLinkedListSetNode *) mono_lls_pointer_unmask (next);
                        if (InterlockedCompareExchangePointer ((volatile gpointer*)prev, next, cur) == cur) {
                                /* The hazard pointer must be cleared after the CAS. */
                                mono_memory_write_barrier ();
                                mono_hazard_pointer_clear (hp, 1);
                                if (list->free_node_func)
-                                       mono_thread_hazardous_free_or_queue (cur, list->free_node_func);
+                                       mono_thread_hazardous_queue_free (cur, list->free_node_func);
                        } else
                                goto try_again;
                }
-               cur = mono_lls_pointer_unmask (next);
+               cur = (MonoLinkedListSetNode *) mono_lls_pointer_unmask (next);
                mono_hazard_pointer_set (hp, 1, cur);
        }
 }
@@ -139,7 +133,6 @@ Insert @value into @list.
 The nodes value, cur and prev are returned in @hp.
 Return true if @value was inserted by this call. If it returns FALSE, it's the caller
 resposibility to release memory.
-This function cannot be called from a signal nor with the world stopped.
 */
 gboolean
 mono_lls_insert (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLinkedListSetNode *value)
@@ -152,8 +145,8 @@ mono_lls_insert (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLink
        while (1) {
                if (mono_lls_find (list, hp, value->key))
                        return FALSE;
-               cur = mono_hazard_pointer_get_val (hp, 1);
-               prev = mono_hazard_pointer_get_val (hp, 2);
+               cur = (MonoLinkedListSetNode *) mono_hazard_pointer_get_val (hp, 1);
+               prev = (MonoLinkedListSetNode **) mono_hazard_pointer_get_val (hp, 2);
 
                value->next = cur;
                mono_hazard_pointer_set (hp, 0, value);
@@ -165,10 +158,9 @@ mono_lls_insert (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLink
 }
 
 /*
-Search @list for element with key @key.
+Search @list for element with key @key and remove it.
 The nodes next, cur and prev are returned in @hp
 Returns true if @value was removed by this call.
-This function cannot be called from a signal nor with the world stopped.
 */
 gboolean
 mono_lls_remove (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLinkedListSetNode *value)
@@ -178,9 +170,9 @@ mono_lls_remove (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLink
                if (!mono_lls_find (list, hp, value->key))
                        return FALSE;
 
-               next = mono_hazard_pointer_get_val (hp, 0);
-               cur = mono_hazard_pointer_get_val (hp, 1);
-               prev = mono_hazard_pointer_get_val (hp, 2);
+               next = (MonoLinkedListSetNode *) mono_hazard_pointer_get_val (hp, 0);
+               cur = (MonoLinkedListSetNode *) mono_hazard_pointer_get_val (hp, 1);
+               prev = (MonoLinkedListSetNode **) mono_hazard_pointer_get_val (hp, 2);
 
                g_assert (cur == value);
 
@@ -188,12 +180,12 @@ mono_lls_remove (MonoLinkedListSet *list, MonoThreadHazardPointers *hp, MonoLink
                        continue;
                /* The second CAS must happen before the first. */
                mono_memory_write_barrier ();
-               if (InterlockedCompareExchangePointer ((volatile gpointer*)prev, next, cur) == cur) {
+               if (InterlockedCompareExchangePointer ((volatile gpointer*)prev, mono_lls_pointer_unmask (next), cur) == cur) {
                        /* The CAS must happen before the hazard pointer clear. */
                        mono_memory_write_barrier ();
                        mono_hazard_pointer_clear (hp, 1);
                        if (list->free_node_func)
-                               mono_thread_hazardous_free_or_queue (value, list->free_node_func);
+                               mono_thread_hazardous_try_free (value, list->free_node_func);
                } else
                        mono_lls_find (list, hp, value->key);
                return TRUE;