How to increase stack size for a ruby app. Recursive app getting: Stack level too deep (SystemStackError)

Solution 1:

This question and its answers appear to date back to Ruby 1.8.x, which used the C stack. Ruby 1.9.x and later use a VM that has its own stack. In Ruby 2.0.0 and later, the size of the VM stack can be controlled via the RUBY_THREAD_VM_STACK_SIZE environment variable.

Solution 2:

If you are sure that you do not have an Infinite recursion situation then your algorythm is pobably not suited for Ruby to execute it in a recirsive manner. Converting an algorythm from recursion to different kind of stack is pretty easy and I suggest you try that. Here is how you can do it.

def recursive(params)
  if some_conditions(params)
     recursive(update_params(params))
  end
end

recursive(starting_params)

will transform into

stack = [starting_params]
while !stack.empty?
  current_params = stack.delete_at(0)
  if some_conditions(current_params)
    stack << update_params(current_params)
  end
end

Solution 3:

Yukihiro Matsumoto writes here

Ruby uses C stack, so that you need to use ulimit to specify a limit on stack depth.

Solution 4:

Ruby uses the C stack so your options include using ulimit or compiling Ruby with some compiler/linker stack size flag. Tail recursion is yet to be implemented and Ruby's current support for recursion isn't so great. As cool and elegant recursion is, you might want to consider coping with the language's limitations and writing your code in a different way.

Solution 5:

Think about what is going on with the code. As other posters have mentioned it is possible to hack the C code of the interpreter. However. the result will be that you are using more RAM and have no guarantee that you won't blow the stack again.

The really good solution would be to come up with an iterative algorithm for what you are trying to do. Sometimes memoisation can help and sometimes you find you are not using the stuff you are pushing on the stack in which case you can replace recursive calls with mutable state.

If you are new to this sort of stuff have a look at SICP here for some ideas...