Merge pull request dlang#21289 from schveiguy/addgcthreadlifetime

Add hooks to the GC to manage thread lifetimes

Author: schveiguy

druntime/src/core/gc/config.d

@@ -12,6 +12,8 @@ import core.stdc.stdio : printf;
 
 __gshared Config config;
 
+private __gshared bool _initialized;
+
 struct Config
 {
     bool disable;            // start disabled
@@ -31,7 +33,9 @@ struct Config
 
     bool initialize()
     {
-        return initConfigOptions(this, "gcopt");
+        if (!_initialized)
+            _initialized = initConfigOptions(this, "gcopt");
+        return _initialized;
     }
 
     void help() @nogc nothrow

druntime/src/core/gc/gcinterface.d

@@ -13,6 +13,8 @@
  */
 module core.gc.gcinterface;
 
+import core.thread.threadbase : ThreadBase;
+
 static import core.memory;
 alias BlkAttr = core.memory.GC.BlkAttr;
 alias BlkInfo = core.memory.GC.BlkInfo;
@@ -270,4 +272,32 @@ interface GC
      * Returns: true if successful.
      */
     bool shrinkArrayUsed(void[] slice, size_t existingUsed, bool atomic = false) nothrow;
+
+    /**
+     * Prepare a thread for use with the GC after the GC is initialized. Note
+     * that you can register an initThread function to call before the GC is
+     * initialized, see core.gc.registry.
+     *
+     * This function is always called *from* the thread as it is being started,
+     * before any static initializers. The thread object parameter may not yet
+     * be registered as `ThreadBase.getThis()`, as this is called before that
+     * happens.
+     */
+    void initThread(ThreadBase thread) nothrow @nogc;
+
+    /**
+     * Clean up any GC related data from the thread before it exits. There is
+     * no equivalent of this function as a hook before the GC is initialized.
+     * That is, the thread init function called before the GC is initialized
+     * (from the registry hook) should assume this function may not be called
+     * on termination if the GC is never initialized.
+     *
+     * Most times, this is called from the thread that is the given thread
+     * reference, but it's possible the `thread` parameter is not the same as
+     * the current thread.
+     *
+     * There is no guarantee the thread is still registered as
+     * `ThreadBase.getThis()`.
+     */
+    void cleanupThread(ThreadBase thread) nothrow @nogc;
 }

druntime/src/core/gc/registry.d

@@ -8,6 +8,7 @@
 module core.gc.registry;
 
 import core.gc.gcinterface : GC;
+import core.thread.threadbase : ThreadBase;
 
 /*@nogc nothrow:*/
 
@@ -21,28 +22,49 @@ import core.gc.gcinterface : GC;
  */
 alias GCFactory = GC function();
 
+/**
+ * A function that will initialize a thread before the GC has been initialized.
+ * Once the GC is initialized, the interface method GC.initThread for each new
+ * thread.
+ */
+alias GCThreadInitFunction = void function(ThreadBase base) nothrow @nogc;
+
 /**
  * Register a GC factory under the given `name`.  This function must be called
  * from a C constructor before druntime is initialized.
  *
  * To use the registered GC, it's name must be specified gcopt runtime option,
  * e.g. by passing $(TT, --DRT-gcopt=gc:my_gc_name) as application argument.
  *
+ * The thread init function will be called *only before* the GC has been
+ * initialized to the registered GC. It is called as the first step in starting
+ * the new thread before the thread is registered with the runtime as a running
+ * thread. This allows any specific thread data that is needed for running the
+ * GC to be registered with the thread object.
+ *
+ * After the GC is initialized, the GC interface function `initThread` is
+ * called instead. This function should expect the possibility that the
+ * reciprocal `cleanupThread` method may not be called if the GC is never
+ * initialized.
+ *
  * Params:
  *   name = name of the GC implementation; should be unique
  *   factory = function to instantiate the implementation
+ *   threadInit = function to call from a new thread *before* registration in
+ *       the list of running threads, to set up any GC-specific data.
  * Note: The registry does not perform synchronization, as registration is
  *   assumed to be executed serially, as is the case for C constructors.
  * See_Also:
  *   $(LINK2 https://dlang.org/spec/garbage.html#gc_config, Configuring the Garbage Collector)
  */
-void registerGCFactory(string name, GCFactory factory) nothrow @nogc
+void registerGCFactory(string name, GCFactory factory,
+        GCThreadInitFunction threadInit = null) nothrow @nogc
 {
     import core.stdc.stdlib : realloc;
 
     auto ptr = cast(Entry*)realloc(entries.ptr, (entries.length + 1) * Entry.sizeof);
     entries = ptr[0 .. entries.length + 1];
-    entries[$ - 1] = Entry(name, factory);
+    entries[$ - 1] = Entry(name, factory, threadInit);
 }
 
 /**
@@ -70,6 +92,22 @@ GC createGCInstance(string name)
     return null;
 }
 
+/**
+ * Get the thread init function used for the selected GC.
+ *
+ * Note, this must be called before `createGCInstance`. It is typically called by
+ * `rt_init`.
+ */
+GCThreadInitFunction threadInit(string name) nothrow @nogc
+{
+    foreach (entry; entries)
+    {
+        if (entry.name == name)
+            return entry.threadInit;
+    }
+    return null;
+}
+
 // list of all registerd GCs
 const(Entry[]) registeredGCFactories(scope int dummy=0) nothrow @nogc
 {
@@ -82,6 +120,7 @@ struct Entry
 {
     string name;
     GCFactory factory;
+    GCThreadInitFunction threadInit;
 }
 
 __gshared Entry[] entries;

druntime/src/core/internal/gc/blkcache.d

@@ -63,17 +63,16 @@ else
 }
 
 // free the allocation on thread exit.
-@standalone static ~this()
+void cleanupBlkCache(void* storage) nothrow @nogc
 {
-    if (__blkcache_storage)
+    if (storage)
     {
+        // check if this is the same thread as the current running thread, and
+        // if so, make sure we don't leave a dangling pointer.
+        if (__blkcache_storage is storage)
+            __blkcache_storage = null;
         import core.stdc.stdlib : free;
-        import core.thread.threadbase;
-        auto tBase = ThreadBase.getThis();
-        if (tBase !is null)
-            tBase.tlsGCData = null;
-        free(__blkcache_storage);
-        __blkcache_storage = null;
+        free(storage);
     }
 }
 

druntime/src/core/internal/gc/impl/conservative/gc.d

@@ -1637,6 +1637,14 @@ class ConservativeGC : GC
 
         return existingCapacity - offset;
     }
+
+    void initThread(ThreadBase t) nothrow @nogc { }
+
+    void cleanupThread(ThreadBase t) nothrow @nogc
+    {
+        cleanupBlkCache(t.tlsGCData);
+        t.tlsGCData = null;
+    }
 }
 
 

druntime/src/core/internal/gc/impl/manual/gc.d

@@ -23,6 +23,8 @@ import core.gc.gcinterface;
 
 import core.internal.container.array;
 
+import core.thread.threadbase : ThreadBase;
+
 import cstdlib = core.stdc.stdlib : calloc, free, malloc, realloc;
 static import core.memory;
 
@@ -287,4 +289,12 @@ class ManualGC : GC
     {
         return false;
     }
+
+    void initThread(ThreadBase t) nothrow @nogc
+    {
+    }
+
+    void cleanupThread(ThreadBase t) nothrow @nogc
+    {
+    }
 }

druntime/src/core/internal/gc/impl/proto/gc.d

@@ -3,6 +3,10 @@ module core.internal.gc.impl.proto.gc;
 
 import core.gc.gcinterface;
 
+import core.gc.registry : GCThreadInitFunction, threadInit;
+
+import core.thread.threadbase : ThreadBase;
+
 import core.internal.container.array;
 
 import cstdlib = core.stdc.stdlib : calloc, free, malloc, realloc;
@@ -28,11 +32,15 @@ private
     extern (C) void gc_addRoot(const void* p ) nothrow @nogc;
 }
 
+
 class ProtoGC : GC
 {
     Array!Root roots;
     Array!Range ranges;
 
+    // stored on first use, which should be called whenever rt_init is called.
+    private GCThreadInitFunction _initThreadFn;
+
     // Call this function when initializing the real GC
     // upon ProtoGC term. This function should be called
     // after the real GC is in place.
@@ -261,4 +269,23 @@ class ProtoGC : GC
     {
         return false;
     }
+
+    void initThread(ThreadBase thread) nothrow
+    {
+        if (_initThreadFn is null)
+        {
+            static void defaultThreadInit(ThreadBase base) nothrow @nogc { }
+            import core.gc.config;
+            config.initialize();
+            _initThreadFn = .threadInit(config.gc);
+            if (_initThreadFn is null)
+                _initThreadFn = &defaultThreadInit;
+        }
+
+        _initThreadFn(thread);
+    }
+
+    void cleanupThread(ThreadBase thread)
+    {
+    }
 }

druntime/src/core/internal/gc/proxy.d

@@ -266,7 +266,7 @@ extern (C)
         return instance.shrinkArrayUsed( slice, existingUsed, atomic );
     }
 
-    GC gc_getProxy() nothrow
+    GC gc_getProxy() nothrow @nogc
     {
         return instance;
     }

druntime/src/core/thread/threadbase.d

@@ -133,6 +133,10 @@ class ThreadBase
     package void tlsRTdataInit() nothrow @nogc
     {
         m_tlsrtdata = rt_tlsgc_init();
+
+        // Let the selected GC initialize anything it needs.
+        import core.internal.gc.proxy : gc_getProxy;
+        gc_getProxy().initThread(this);
     }
 
     package void initDataStorage() nothrow
@@ -146,6 +150,10 @@ class ThreadBase
 
     package void destroyDataStorage() nothrow @nogc
     {
+        // allow the GC to clean up any resources it allocated for this thread.
+        import core.internal.gc.proxy : gc_getProxy;
+        gc_getProxy().cleanupThread(this);
+
         rt_tlsgc_destroy(m_tlsrtdata);
         m_tlsrtdata = null;
     }

druntime/test/init_fini/src/custom_gc.d

@@ -4,6 +4,8 @@ import core.stdc.stdlib : calloc, malloc, realloc;
 
 static import core.memory;
 
+import core.thread.threadbase : ThreadBase;
+
 extern (C) __gshared string[] rt_options = ["gcopt=gc:malloc"];
 
 extern (C) pragma(crt_constructor) void register_mygc()
@@ -209,6 +211,14 @@ nothrow @nogc:
         return false;
     }
 
+    void initThread(ThreadBase thread) nothrow @nogc
+    {
+    }
+
+    void cleanupThread(ThreadBase thread) nothrow @nogc
+    {
+    }
+
 private:
     // doesn't care for alignment
     static void* sentinelAdd(void* p, size_t value)