X-Git-Url: https://pd.if.org/git/?p=nbds;a=blobdiff_plain;f=runtime%2Fhazard.c;h=431c57665029b72db1d21c8fd34b90458cce3184;hp=72ed0c12c609d4de0f04854948fdf81c7d59e3ff;hb=75b0d2f02f548b3a1e4daba8b0d55eea2fb24e92;hpb=a03cf3b0c40e6c3b8b4877b49a64288cb3fcb919

diff --git a/runtime/hazard.c b/runtime/hazard.c
index 72ed0c1..431c576 100644
--- a/runtime/hazard.c
+++ b/runtime/hazard.c
@@ -13,6 +13,7 @@
 #include "tls.h"
 #include "runtime.h"
 #include "hazard.h"
+#include "lwt.h"
 
 typedef struct pending {
     void * ptr; 
@@ -30,25 +31,30 @@ typedef struct haz_local {
     int dynamic_size;
     int dynamic_count;
 
-} haz_local_t;
+} __attribute__ ((aligned(CACHE_LINE_SIZE))) haz_local_t;
 
 static haz_local_t haz_local_[MAX_NUM_THREADS] = {};
 
 static void sort_hazards (haz_t *hazards, int n) {
+    TRACE("H3", "sort_hazards: sorting hazard list %p of %p elements", hazards, n);
     return;
 }
 
 static int search_hazards (void *p, haz_t *hazards, int n) {
+    TRACE("H4", "search_hazards: searching list %p for hazard %p", hazards, p);
     for (int i = 0; i < n; ++i) {
-        if (hazards[i] == p) 
+        if (hazards[i] == p) {
+            TRACE("H2", "haz_search_hazards: found hazard %p", p, 0);
             return TRUE;
+        }
     }
     return FALSE;
 }
 
 static void resize_pending (void) {
-    LOCALIZE_THREAD_LOCAL(tid_, int);
-    haz_local_t *l = haz_local_ + tid_;
+    TRACE("H2", "haz_resize_pending", 0, 0);
+    LOCALIZE_THREAD_LOCAL(ThreadId, int);
+    haz_local_t *l = haz_local_ + ThreadId;
     pending_t *p = nbd_malloc(sizeof(pending_t) * l->pending_size * 2);
     memcpy(p, l->pending, l->pending_size);
     nbd_free(l->pending);
@@ -57,10 +63,11 @@ static void resize_pending (void) {
 }
 
 void haz_defer_free (void *d, free_t f) {
+    TRACE("H1", "haz_defer_free: %p (%p)", d, f);
     assert(d);
     assert(f);
-    LOCALIZE_THREAD_LOCAL(tid_, int);
-    haz_local_t *l = haz_local_ + tid_;
+    LOCALIZE_THREAD_LOCAL(ThreadId, int);
+    haz_local_t *l = haz_local_ + ThreadId;
     while (l->pending_count == l->pending_size) {
 
         if (l->pending_size == 0) {
@@ -114,25 +121,32 @@ void haz_defer_free (void *d, free_t f) {
         l->pending_count = conflicts_count;
         nbd_free(hazards);
     }
-    l->pending[ l->pending_count ].ptr  = d;
+    assert(l->pending_size > l->pending_count);
+    l->pending[ l->pending_count ].ptr   = d;
     l->pending[ l->pending_count ].free_ = f;
     l->pending_count++;
 }
 
 haz_t *haz_get_static (int i) {
+    TRACE("H1", "haz_get_static: %p", i, 0);
     if (i >= STATIC_HAZ_PER_THREAD)
         return NULL;
-    LOCALIZE_THREAD_LOCAL(tid_, int);
-    return &haz_local_[tid_].static_haz[i];
+    LOCALIZE_THREAD_LOCAL(ThreadId, int);
+    assert(i < STATIC_HAZ_PER_THREAD);
+    haz_t *ret = &haz_local_[ThreadId].static_haz[i];
+    TRACE("H1", "haz_get_static: returning %p", ret, 0);
+    return ret;
 }
 
 void haz_register_dynamic (haz_t *haz) {
-    LOCALIZE_THREAD_LOCAL(tid_, int);
-    haz_local_t *l = haz_local_ + tid_;
+    TRACE("H1", "haz_register_dynamic: %p", haz, 0);
+    LOCALIZE_THREAD_LOCAL(ThreadId, int);
+    haz_local_t *l = haz_local_ + ThreadId;
 
     if (l->dynamic_size == 0) {
-        l->dynamic_size = MAX_NUM_THREADS * STATIC_HAZ_PER_THREAD;
-        l->dynamic = nbd_malloc(sizeof(haz_t *) * l->dynamic_size);
+        int n = MAX_NUM_THREADS * STATIC_HAZ_PER_THREAD;
+        l->dynamic = nbd_malloc(sizeof(haz_t *) * n);
+        l->dynamic_size = n;
     }
 
     if (l->dynamic_count == l->dynamic_size) {
@@ -148,13 +162,14 @@ void haz_register_dynamic (haz_t *haz) {
 
 // assumes <haz> was registered in the same thread
 void haz_unregister_dynamic (void **haz) {
-    LOCALIZE_THREAD_LOCAL(tid_, int);
-    haz_local_t *l = haz_local_ + tid_;
+    TRACE("H1", "haz_unregister_dynamic: %p", haz, 0);
+    LOCALIZE_THREAD_LOCAL(ThreadId, int);
+    haz_local_t *l = haz_local_ + ThreadId;
 
     for (int i = 0; i < l->dynamic_count; ++i) {
         if (l->dynamic[i] == haz) {
             if (i != l->dynamic_count - 1) {
-                l->dynamic[i] = l->dynamic[ l->dynamic_count ];
+                l->dynamic[i] = l->dynamic[ l->dynamic_count - 1 ];
             }
             l->dynamic_count--;
             return;