PoC: Replace Thread::Local(T) with Thread::LocalStorage (alternative)

samples/sdl/tv.cr

@@ -64,7 +64,7 @@ class ColorMaker
   end
 
   def make_alpha_color(multiplier)
-    rand = Random::DEFAULT.next_int
+    rand = Random.default.next_int
     r = ((rand >> 16) % 256).to_i
     g = ((rand >> 8) % 256).to_i
     b = (rand % 256).to_i

spec/std/file_spec.cr

@@ -64,7 +64,7 @@ describe "File" do
 
       rbuf = Bytes.new(5120)
       wbuf = Bytes.new(5120)
-      Random::DEFAULT.random_bytes(wbuf)
+      Random.default.random_bytes(wbuf)
 
       File.open(path, "r") do |reader|
         # opened fifo for read: wait for thread to open for write

spec/std/random_spec.cr

@@ -196,7 +196,7 @@ describe "Random" do
   end
 
   it "gets a random bool" do
-    Random::DEFAULT.next_bool.should be_a(Bool)
+    Random.default.next_bool.should be_a(Bool)
   end
 
   it "generates by accumulation" do

spec/std/spec/context_spec.cr

@@ -6,7 +6,7 @@ describe Spec::ExampleGroup do
       root = build_spec("f.cr", count: 20)
 
       before_randomize = all_spec_descriptions(root)
-      root.randomize(Random::DEFAULT)
+      root.randomize(Random.default)
       after_randomize = all_spec_descriptions(root)
 
       after_randomize.should_not eq before_randomize

src/array.cr

@@ -1606,7 +1606,7 @@ class Array(T)
 
   # Returns an array with all the elements in the collection randomized
   # using the given *random* number generator.
-  def shuffle(random : Random = Random::DEFAULT) : Array(T)
+  def shuffle(random : Random = Random.default) : Array(T)
     dup.shuffle!(random)
   end
 

src/colorize.cr

@@ -91,7 +91,7 @@
 # ```
 # require "colorize"
 #
-# "foo".colorize(Random::DEFAULT.next_bool ? :green : :default)
+# "foo".colorize(Random.default.next_bool ? :green : :default)
 # ```
 #
 # Available colors are:

src/crystal/system/file.cr

@@ -51,7 +51,7 @@ module Crystal::System::File
 
   LOWER_ALPHANUM = "0123456789abcdefghijklmnopqrstuvwxyz".to_slice
 
-  def self.mktemp(prefix : String?, suffix : String?, dir : String, random : ::Random = ::Random::DEFAULT) : {FileDescriptor::Handle, String, Bool}
+  def self.mktemp(prefix : String?, suffix : String?, dir : String, random : ::Random = ::Random.default) : {FileDescriptor::Handle, String, Bool}
     flags = LibC::O_RDWR | LibC::O_CREAT | LibC::O_EXCL
     perm = ::File::Permissions.new(0o600)
 

src/crystal/system/thread.cr

@@ -45,6 +45,8 @@ end
   {% raise "Thread not supported" %}
 {% end %}
 
+require "./thread_local_storage"
+
 # :nodoc:
 class Thread
   include Crystal::System::Thread

src/crystal/system/thread_local_storage.cr

@@ -0,0 +1,119 @@
+{% if flag?(:win32) && flag?(:gnu) %}
+  require "c/fibersapi"
+{% end %}
+
+# :nodoc:
+class Thread
+  # :nodoc:
+  #
+  # The GC can't access the local storage, so we must keep a pointer to the
+  # table on the Thread local that is reachable for as long as the thread is
+  # alive.
+  #
+  # We could spare this pointer if the table was uncollectible: the GC allocates
+  # the memory, always scans it (even without explicit references) and never
+  # collects it until it's explicitly told to be freed.
+  protected property local_storage : LocalStorage?
+
+  # :nodoc:
+  class LocalStorage
+    # FIXME: we should be able to use @[ThreadLocal] on every target: the
+    # compiler needs to set the llvm::TargetOptions::EmulatedLTS option for
+    # Android < 29, MinGW and OpenBSD, though mostly for overall consistency
+    # since it might be set by default for some targets already.
+
+    {% if flag?(:android) || flag?(:openbsd) %}
+      @@key = uninitialized LibC::PthreadKeyT
+      err = LibC.pthread_key_create(pointerof(@@key), nil)
+      raise RuntimeError.from_os_error("pthread_key_create", Errno.new(err)) unless err == 0
+
+      def self.local_table? : LocalStorage?
+        ptr = LibC.pthread_getspecific(@@key)
+        ptr.as(LocalStorage) unless ptr.null?
+      end
+
+      def self.local_table=(local_table : LocalStorage)
+        err = LibC.pthread_setspecific(@@key, local_table.as(Void*))
+        raise RuntimeError.from_os_error("pthread_setspecific", Errno.new(err)) unless err == 0
+        Thread.current.local_storage = local_table
+      end
+    {% elsif flag?(:win32) && flag?(:gnu) %}
+      @@key = uninitialized LibC::DWORD
+      @@key = LibC.FlsAlloc(nil)
+      raise RuntimeError.from_winerror("FlsAlloc: out of indexes") if @@key == LibC::FLS_OUT_OF_INDEXES
+
+      def self.local_table? : LocalStorage?
+        ptr = LibC.FlsGetValue(@@key)
+        ptr.as(LocalStorage) unless ptr.null?
+      end
+
+      def self.local_table=(local_table : LocalStorage)
+        ret = LibC.FlsSetValue(@@key, local_table.as(Void*))
+        raise RuntimeError.from_winerror("FlsSetValue") if ret == 0
+        Thread.current.local_storage = local_table
+      end
+    {% else %}
+      @[ThreadLocal]
+      @@local_table : LocalStorage?
+
+      def self.local_table? : LocalStorage?
+        @@local_table
+      end
+
+      def self.local_table=(@@local_table : LocalStorage)
+        Thread.current.local_storage = local_table
+      end
+    {% end %}
+
+    def self.local_table : LocalStorage
+      local_table? || self.local_table = LocalStorage.new
+    end
+
+    def finalize
+      {% for var, index in @type.class_vars %}
+        {% if var.name.starts_with?("__destructor") %}
+          @@{{var.name}}.try(&.call(self)) rescue nil
+        {% end %}
+      {% end %}
+    end
+  end
+
+  macro thread_local(decl, destructor = nil)
+    {% raise "Expected TypeDeclaration" unless decl.is_a?(TypeDeclaration) %}
+
+    protected def self.{{decl.var.id}}(&block : -> {{decl.type}}) : {{decl.type}}
+      table = ::Thread::LocalStorage.local_table
+      if (value = table.%var).nil?
+        {% if destructor %}
+          ::Thread::LocalStorage.__set_destructor%var
+        {% end %}
+        table.%var = yield
+      else
+        value
+      end
+    end
+
+    class ::Thread::LocalStorage
+      property %var : {{decl.type}} | Nil
+
+      {% if destructor %}
+        @@__destructor%var = uninitialized Proc(self, Nil)
+        @@__once_destructor%var = Atomic(Bool).new(false)
+
+        # delay setting the destructor to when we need it, to avoid extra
+        # dependencies just because we declared a TLS but don't use it (for
+        # example libpcre2)
+        def self.__set_destructor%var
+          return if @@__once_destructor%var.swap(true, :relaxed)
+
+          @@__destructor%var = ->(table : self) {
+            if value = table.%var
+              {{destructor}}.call(value)
+            end
+            nil
+          }
+        end
+      {% end %}
+    end
+  end
+end

src/enumerable.cr

@@ -1577,7 +1577,7 @@ module Enumerable(T)
   # {1, 2, 3, 4, 5}.sample(2)                # => [3, 4]
   # {1, 2, 3, 4, 5}.sample(2, Random.new(1)) # => [1, 5]
   # ```
-  def sample(n : Int, random : Random = Random::DEFAULT) : Array(T)
+  def sample(n : Int, random : Random = Random.default) : Array(T)
     raise ArgumentError.new("Can't sample negative number of elements") if n < 0
 
     # Unweighted reservoir sampling:
@@ -1613,7 +1613,7 @@ module Enumerable(T)
   # a.sample                # => 1
   # a.sample(Random.new(1)) # => 3
   # ```
-  def sample(random : Random = Random::DEFAULT) : T
+  def sample(random : Random = Random.default) : T
     value = uninitialized T
     found = false
 

src/http/web_socket/protocol.cr

@@ -136,7 +136,7 @@ class HTTP::WebSocket::Protocol
   private def write_payload(data)
     return @io.write(data) unless @masked
 
-    key = Random::DEFAULT.next_int
+    key = Random.default.next_int
     mask_array = key.unsafe_as(StaticArray(UInt8, 4))
     @io.write mask_array.to_slice
 

src/indexable.cr

@@ -954,7 +954,7 @@ module Indexable(T)
   # a.sample                # => 1
   # a.sample(Random.new(1)) # => 2
   # ```
-  def sample(random : Random = Random::DEFAULT)
+  def sample(random : Random = Random.default)
     raise IndexError.new("Can't sample empty collection") if size == 0
     unsafe_fetch(random.rand(size))
   end
@@ -964,7 +964,7 @@ module Indexable(T)
   # If `self` is not empty and `n` is equal to 1, calls `sample(random)` exactly
   # once. Thus, *random* will be left in a different state compared to the
   # implementation in `Enumerable`.
-  def sample(n : Int, random : Random = Random::DEFAULT) : Array(T)
+  def sample(n : Int, random : Random = Random.default) : Array(T)
     return super unless n == 1
 
     if empty?

src/indexable/mutable.cr

@@ -259,7 +259,7 @@ module Indexable::Mutable(T)
   # a.shuffle!(Random.new(42)) # => [3, 2, 4, 5, 1]
   # a                          # => [3, 2, 4, 5, 1]
   # ```
-  def shuffle!(random : Random = Random::DEFAULT) : self
+  def shuffle!(random : Random = Random.default) : self
     (size - 1).downto(1) do |i|
       j = random.rand(i + 1)
       swap(i, j)

src/kernel.cr

@@ -593,6 +593,7 @@ end
 
         # additional reinitialization
         ->Random::DEFAULT.new_seed,
+        -> { Random.default.new_seed },
       ] of -> Nil
     end
   end

src/pointer.cr

@@ -382,7 +382,7 @@ struct Pointer(T)
   # ptr.shuffle!(4)
   # ptr # [3, 4, 1, 2]
   # ```
-  def shuffle!(count : Int, random = Random::DEFAULT)
+  def shuffle!(count : Int, random = Random.default)
     (count - 1).downto(1) do |i|
       j = random.rand(i + 1)
       swap(i, j)