Changeset 5298

Timestamp:

01/14/10 17:25:35 (2 years ago)

Author:

kris

Message:

tentative support for weak-references, courtesy of wm4

Files:

• trunk/tango/core/Memory.d (modified) (4 diffs)
• trunk/tango/core/WeakRef.d (added)
• trunk/tango/core/rt/gc/basic/gc.d (modified) (1 diff)
• trunk/tango/core/rt/gc/basic/gcx.d (modified) (2 diffs)
• trunk/tango/core/rt/gc/stub/gc.d (modified) (1 diff)

trunk/tango/core/Memory.d

@@ -48 +48 @@
-    extern (C) void gc_removeRoot( void* p );
-    extern (C) void gc_removeRange( void* p );
+
+    extern(C) Object gc_weakpointerGet (void* wp);
+    extern(C) void*  gc_weakpointerCreate (Object r);
+    extern(C) void   gc_weakpointerDestroy (void* wp);
-}
-
@@ -442 +446 @@
-    }
-    
+
+    /**
+     * Create a weak pointer to the given object.
+     * Returns a pointer to an opaque struct allocated in C memory.
+     */
+    static void* weakPointerCreate( Object o )
+    {
+        return gc_weakpointerCreate (o);
+    }
+
+
+    /**
+     * Destroy a weak pointer returned by weakpointerCreate().
+     * If null is passed, nothing happens.
+     */
+    static void weakPointerDestroy( void* p )
+    {
+        return gc_weakpointerDestroy (p);
+    }
+
+
+    /**
+     * Query a weak pointer and return either the object passed to
+     * weakpointerCreate, or null if it was free'd in the meantime.
+     * If null is passed, null is returned.
+     */
+    static Object weakPointerGet( void* p )
+    {
+        return gc_weakpointerGet (p);
+    }
+
+
-    /**
-    * returns the amount to allocate to keep some extra space
@@ -450 +486 @@
-    * elSize = size of one element
-    */
-
-
-
-
-
-
+
+
+
+
-    
-
-        static size_t log2plusB(size_t c)
-        {
-            // could use the bsr bit op
-            size_t i=b+1;
-            while(c >>= 1){
-                ++i;
-            }
-            return i;
-        }
-        long mult = 100 + a*(minBits+b) / log2plusB(newlength);
-
-        newext = elSize*cast(size_t)(((newcap * mult)+99) / 100);
-        newcap = newext > newcap ? newext : newcap; // just to handle overflows
-        return newcap;
-    }
-    
-    /**
-    * returns the amount to allocate to keep some extra space
@@ -485 +503 @@
-    * minBits = minimum number of bits of newlength
-    */
-
-
-
+
+
-        static size_t log2(size_t c)
-        {
-            // could use the bsr bit op
-            size_t i=1;
-
-
-
+
+
-            return i;
-        }
+
+        size_t newext = 0;
+        size_t newcap = newlength*elSize;
-        long mult = 100 + a*(minBits+b) / (log2(newlength)+b);
-
-        newext = elSize*cast(size_t)(((newcap * mult)+99) / 100);
-        newcap = newext > newcap ? newext : newcap; // just to handle overflows

trunk/tango/core/rt/gc/basic/gc.d

@@ -218 +218 @@
-    _gc.removeRange( p );
-}
+
+extern (C) void* gc_weakpointerCreate( Object r )
+{
+    return _gc.weakpointerCreate(r);
+}
+
+extern (C) void gc_weakpointerDestroy( void* wp )
+{
+    _gc.weakpointerDestroy(wp);
+}
+
+extern (C) Object gc_weakpointerGet( void* wp )
+{
+    return _gc.weakpointerGet(wp);
+}

trunk/tango/core/rt/gc/basic/gcx.d

@@ -88 +88 @@
-
-    extern (C) void rt_finalize( void* p, bool det = true );
+
+    alias void delegate(Object) DEvent;
+    extern (C) void rt_attachDisposeEvent(Object h, DEvent e);
+    extern (C) bool rt_detachDisposeEvent(Object h, DEvent e);
-
-    alias void delegate( void*, void* ) scanFn;
@@ -1339 +1343 @@
-        stats.freelistsize = flsize;
-    }
+
+    /******************* weak-reference support *********************/
+
+    //call locked if necessary
+    private T locked(T)(in T delegate() code) 
+    {
+        if (thread_needLock)
+            synchronized(gcLock) return code();
+        else
+           return code();
+    }
+
+    private struct WeakPointer 
+    {
+        Object reference;
+
+        void ondestroy(Object r) 
+        {
+            assert(r is reference);
+            //lock for memory consistency (parallel readers)
+            //
+            //also ensures that weakpointerDestroy can be called while another
+            //thread is freeing the reference with "delete"                    
+            locked!(void)({ reference = null; });
+        }
+    }
+
+    /**
+     * Create a weak pointer to the given object.
+     * Returns a pointer to an opaque struct allocated in C memory.
+     */
+    void* weakpointerCreate( Object r )
+    {
+        if (r)
+           {
+           //must be allocated in C memory
+           //1. to hide the reference from the GC
+           //2. the GC doesn't scan delegates added by rt_attachDisposeEvent for references
+           auto wp = cast(WeakPointer*)(.malloc(WeakPointer.sizeof));
+           if (!wp)
+               onOutOfMemoryError();
+           *wp = WeakPointer.init;
+           wp.reference = r;
+           rt_attachDisposeEvent(r, &wp.ondestroy);
+           return wp;
+           }
+        return null;
+    }
+
+    /**
+     * Destroy a weak pointer returned by weakpointerCreate().
+     * If null is passed, nothing happens.
+     */
+    void weakpointerDestroy( void* p )
+    {
+        if (p)        
+           {
+           auto wp = cast(WeakPointer*)p;
+           //must be extra careful about the GC or parallel threads finalizing the
+           //reference at the same time
+           locked!(void)({
+                   if (wp.reference)
+                       rt_detachDisposeEvent(wp.reference, &wp.ondestroy);
+                  });
+           .free(wp);
+           }
+    }
+
+    /**
+     * Query a weak pointer and return either the object passed to
+     * weakpointerCreate, or null if it was free'd in the meantime.
+     * If null is passed, null is returned.
+     */
+    Object weakpointerGet( void* p )
+    {
+        if (p)
+           {
+           //NOTE: could avoid the lock by using Fawzi style GC counters
+           // but that'd require core.sync.Atomic and lots of care about memory consistency
+           // it's an optional optimization
+           //see http://dsource.org/projects/tango/browser/trunk/user/tango/core/Lifetime.d?rev=5100#L158
+           return locked!(Object)({
+                  return (cast(WeakPointer*)p).reference;
+                  });
+           }
+    }
-}
-

trunk/tango/core/rt/gc/stub/gc.d

@@ -164 +164 @@
-
-}
+
+//weakpointers are simply the pointers itself
+extern (C) void* gc_weakpointerCreate( Object r )
+{
+    return cast(void*)r;
+}
+
+extern (C) void gc_weakpointerDestroy( void* wp )
+{
+
+}
+
+extern (C) Object gc_weakpointerGet( void* wp )
+{
+    return cast(Object)wp;
+}