Initialize Fiber with an explicit stack

src/compiler/crystal/interpreter/context.cr

@@ -106,10 +106,10 @@ class Crystal::Repl::Context
   # Once the block returns, the stack is returned to the pool.
   # The stack is not cleared after or before it's used.
   def checkout_stack(& : UInt8* -> _)
-    stack, _ = @stack_pool.checkout
+    stack = @stack_pool.checkout
 
     begin
-      yield stack.as(UInt8*)
+      yield stack.pointer.as(UInt8*)
     ensure
       @stack_pool.release(stack)
     end

src/crystal/scheduler.cr

@@ -124,7 +124,7 @@ class Crystal::Scheduler
     {% elsif flag?(:interpreted) %}
       # No need to change the stack bottom!
     {% else %}
-      GC.set_stackbottom(fiber.@stack_bottom)
+      GC.set_stackbottom(fiber.@stack.bottom)
     {% end %}
 
     current, @thread.current_fiber = @thread.current_fiber, fiber

src/crystal/system/unix/signal.cr

@@ -183,8 +183,8 @@ module Crystal::System::Signal
 
     is_stack_overflow =
       begin
-        stack_top = Pointer(Void).new(::[email protected] - 4096)
-        stack_bottom = ::Fiber.current.@stack_bottom
+        stack_top = Pointer(Void).new(::Fiber.current.@stack.pointer.address - 4096)
+        stack_bottom = ::Fiber.current.@stack.bottom
         stack_top <= addr < stack_bottom
       rescue e
         Crystal::System.print_error "Error while trying to determine if a stack overflow has occurred. Probable memory corruption\n"

src/fiber.cr

@@ -1,6 +1,7 @@
 require "crystal/system/thread_linked_list"
 require "crystal/print_buffered"
 require "./fiber/context"
+require "./fiber/stack"
 
 # :nodoc:
 @[NoInline]
@@ -56,12 +57,11 @@ class Fiber
   end
 
   @context : Context
-  @stack : Void*
+  @stack : Stack
   @resume_event : Crystal::EventLoop::Event?
   @timeout_event : Crystal::EventLoop::Event?
   # :nodoc:
   property timeout_select_action : Channel::TimeoutAction?
-  protected property stack_bottom : Void*
 
   # The name of the fiber, used as internal reference.
   property name : String?
@@ -97,31 +97,30 @@ class Fiber
   # When the fiber is executed, it runs *proc* in its context.
   #
   # *name* is an optional and used only as an internal reference.
-  def initialize(@name : String? = nil, &@proc : ->)
-    @context = Context.new
-    @stack, @stack_bottom =
+  def self.new(name : String? = nil, &proc : ->)
+    stack =
       {% if flag?(:interpreted) %}
-        {Pointer(Void).null, Pointer(Void).null}
+        # the interpreter is managing the stacks
+        Stack.new(Pointer(Void).null, 0)
       {% else %}
         Crystal::Scheduler.stack_pool.checkout
       {% end %}
+    new(name, stack, &proc)
+  end
 
-    fiber_main = ->(f : Fiber) { f.run }
-
-    # point to first addressable pointer on the stack (@stack_bottom points past
-    # the stack because the stack grows down):
-    stack_ptr = @stack_bottom - sizeof(Void*)
-
-    # align the stack pointer to 16 bytes:
-    stack_ptr = Pointer(Void*).new(stack_ptr.address & ~0x0f_u64)
+  # :nodoc:
+  def initialize(@name : String?, @stack : Stack, &@proc : ->)
+    @context = Context.new
 
+    fiber_main = ->(f : Fiber) { f.run }
+    stack_ptr = @stack.first_addressable_pointer
     makecontext(stack_ptr, fiber_main)
 
     Fiber.fibers.push(self)
   end
 
   # :nodoc:
-  def initialize(@stack : Void*, thread)
+  def initialize(stack : Void*, thread)
     @proc = Proc(Void).new { }
 
     # TODO: should creating a new context for the main fiber also be platform specific?
@@ -133,7 +132,10 @@ class Fiber
       {% else %}
         Context.new(_fiber_get_stack_top)
       {% end %}
-    thread.gc_thread_handler, @stack_bottom = GC.current_thread_stack_bottom
+
+    thread.gc_thread_handler, stack_bottom = GC.current_thread_stack_bottom
+    @stack = Stack.new(stack, stack_bottom)
+
     @name = "main"
     {% if flag?(:preview_mt) %} @current_thread.set(thread) {% end %}
     Fiber.fibers.push(self)
@@ -317,7 +319,7 @@ class Fiber
   # :nodoc:
   def push_gc_roots : Nil
     # Push the used section of the stack
-    GC.push_stack @context.stack_top, @stack_bottom
+    GC.push_stack @context.stack_top, @stack.bottom
   end
 
   {% if flag?(:preview_mt) %}

src/fiber/context/aarch64-microsoft.cr

@@ -13,16 +13,16 @@ class Fiber
 
     # actual stack top, not including guard pages and reserved pages
     LibC.GetNativeSystemInfo(out system_info)
-    stack_top = @stack_bottom - system_info.dwPageSize
+    stack_top = @stack.bottom - system_info.dwPageSize
 
     stack_ptr[-4] = self.as(Void*)      # x0 (r0): puts `self` as first argument for `fiber_main`
     stack_ptr[-16] = fiber_main.pointer # x30 (lr): initial `resume` will `ret` to this address
 
     # The following three values are stored in the Thread Information Block (NT_TIB)
     # and are used by Windows to track the current stack limits
-    stack_ptr[-3] = @stack        # [x18, #0x1478]: Win32 DeallocationStack
-    stack_ptr[-2] = stack_top     # [x18, #16]: Stack Limit
-    stack_ptr[-1] = @stack_bottom # [x18, #8]: Stack Base
+    stack_ptr[-3] = @stack.pointer # [x18, #0x1478]: Win32 DeallocationStack
+    stack_ptr[-2] = stack_top      # [x18, #16]: Stack Limit
+    stack_ptr[-1] = @stack.bottom  # [x18, #8]: Stack Base
   end
 
   # :nodoc:

src/fiber/context/x86_64-microsoft.cr

@@ -12,17 +12,17 @@ class Fiber
 
     # actual stack top, not including guard pages and reserved pages
     LibC.GetNativeSystemInfo(out system_info)
-    stack_top = @stack_bottom - system_info.dwPageSize
+    stack_top = @stack.bottom - system_info.dwPageSize
 
     stack_ptr -= 4                    # shadow space (or home space) before return address
     stack_ptr[0] = fiber_main.pointer # %rbx: Initial `resume` will `ret` to this address
     stack_ptr[-1] = self.as(Void*)    # %rcx: puts `self` as first argument for `fiber_main`
 
     # The following three values are stored in the Thread Information Block (NT_TIB)
     # and are used by Windows to track the current stack limits
-    stack_ptr[-2] = @stack        # %gs:0x1478: Win32 DeallocationStack
-    stack_ptr[-3] = stack_top     # %gs:0x10: Stack Limit
-    stack_ptr[-4] = @stack_bottom # %gs:0x08: Stack Base
+    stack_ptr[-2] = @stack.pointer # %gs:0x1478: Win32 DeallocationStack
+    stack_ptr[-3] = stack_top      # %gs:0x10: Stack Limit
+    stack_ptr[-4] = @stack.bottom  # %gs:0x08: Stack Base
   end
 
   # :nodoc:

src/fiber/stack.cr

@@ -0,0 +1,25 @@
+class Fiber
+  # :nodoc:
+  struct Stack
+    getter pointer : Void*
+    getter bytesize : Int32
+    getter? reusable : Bool
+
+    def initialize(@pointer, bottom : Void*, *, @reusable = false)
+      @bytesize = (bottom - @pointer).to_i32
+    end
+
+    def initialize(@pointer, @bytesize, *, @reusable = false)
+    end
+
+    def bottom : Void*
+      @pointer + @bytesize
+    end
+
+    def first_addressable_pointer : Void**
+      ptr = bottom                              # stacks grow down
+      ptr -= sizeof(Void*)                      # point to first addressable pointer
+      Pointer(Void*).new(ptr.address & ~15_u64) # align to 16 bytes
+    end
+  end
+end

src/fiber/stack_pool.cr

@@ -12,12 +12,12 @@ class Fiber
     # Interpreter stacks grow upwards (pushing values increases the stack
     # pointer value) rather than downwards, so *protect* must be false.
     def initialize(@protect : Bool = true)
-      @deque = Deque(Void*).new
+      @deque = Deque(Stack).new
     end
 
     def finalize
       @deque.each do |stack|
-        Crystal::System::Fiber.free_stack(stack, STACK_SIZE)
+        Crystal::System::Fiber.free_stack(stack.pointer, stack.bytesize)
       end
     end
 
@@ -26,7 +26,7 @@ class Fiber
     def collect(count = lazy_size // 2) : Nil
       count.times do
         if stack = @deque.shift?
-          Crystal::System::Fiber.free_stack(stack, STACK_SIZE)
+          Crystal::System::Fiber.free_stack(stack.pointer, stack.bytesize)
         else
           return
         end
@@ -41,18 +41,19 @@ class Fiber
     end
 
     # Removes a stack from the bottom of the pool, or allocates a new one.
-    def checkout : {Void*, Void*}
+    def checkout : Stack
       if stack = @deque.pop?
-        Crystal::System::Fiber.reset_stack(stack, STACK_SIZE, @protect)
+        Crystal::System::Fiber.reset_stack(stack.pointer, stack.bytesize, @protect)
+        stack
       else
-        stack = Crystal::System::Fiber.allocate_stack(STACK_SIZE, @protect)
+        pointer = Crystal::System::Fiber.allocate_stack(STACK_SIZE, @protect)
+        Stack.new(pointer, STACK_SIZE, reusable: true)
       end
-      {stack, stack + STACK_SIZE}
     end
 
     # Appends a stack to the bottom of the pool.
-    def release(stack) : Nil
-      @deque.push(stack)
+    def release(stack : Stack) : Nil
+      @deque.push(stack) if stack.reusable?
     end
 
     # Returns the approximated size of the pool. It may be equal or slightly

src/gc/boehm.cr

@@ -223,7 +223,7 @@ module GC
         {% if flag?(:preview_mt) %}
           Thread.unsafe_each do |thread|
             if fiber = thread.current_fiber?
-              GC.set_stackbottom(thread.gc_thread_handler, fiber.@stack_bottom)
+              GC.set_stackbottom(thread.gc_thread_handler, fiber.@stack.bottom)
             end
           end
         {% end %}