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

Question

Posting a stack overflow question on stackoverflow.com, how amusing :-)

I'm running some recursive Ruby code and I get the: "Stack level too deep (SystemStackError)"

(I'm quite sure the code works, that I'm not in an infinite recursive death spiral, but that is not the point anyway)

Is there anyway to change the allowed stack depth/size for my Ruby app?

I don't quite get it if this is a restriction in Ruby, since the error says "Stack level", which gives me the impression that Ruby somehow counts 'levels' of stack, or if it simply means that the stack is full.

I have tried running this program under both Vista and Ubuntu with same result. Under Ubuntu i tried changing the stack size with 'ulimit -s' from 8192 to 16000, but that didn't change anything.

Edit: Thanks for the feedback.
I do realize that using a recursive function perhaps isn't the most robust way to go. But that isn't the point either. I simply wonder if there is a way to increase the stack size.. period. And as I mentioned i did try running ulimit -s 16000 before running the ruby script.. with no improvement.. Am I using it wrong?

Edit2: I was in fact having an infinite recursion in an edge case of the code.
The truncated ruby stack trace when you get the "Stack level too deep" error is a bit misleading.
When having a recursive behavior involving several functions, you get the impression that the numbers of recursions is much lower than it actually is. In this example one might thing that it crashes after little bit more than 190 calls, but it is actually around 15000 calls

tst.rb:8:in `p': stack level too deep (SystemStackError)
        from tst.rb:8:in `bar'
        from tst.rb:12:in `bar'
        from tst.rb:19:in `foo'
        from tst.rb:10:in `bar'
        from tst.rb:19:in `foo'
        from tst.rb:10:in `bar'
        from tst.rb:19:in `foo'
        from tst.rb:10:in `bar'
         ... 190 levels...
        from tst.rb:19:in `foo'
        from tst.rb:10:in `bar'
        from tst.rb:19:in `foo'
        from tst.rb:22

-Andreas

Answer 1

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.

Answer 2

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.

Answer 3

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

Answer 4

Yukihiro Matsumoto writes here

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

Answer 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...

Answer 6

Just had the same issue and it is very easy to fix on Linux or on Mac. As said in the other answers, Ruby uses the system stack setting. You can easily change this on Mac and Linux by setting the stack size. Fox example:

ulimit -s 20000

Answer 7

As of Ruby 1.9.2 you can turn on tail-call optimization with something like:

RubyVM::InstructionSequence.compile_option = {
  tailcall_optimization: true,
  trace_instruction: false
}

RubyVM::InstructionSequence.new(<<-EOF).eval
  def me_myself_and_i
    me_myself_and_i
  end
EOF
me_myself_and_i # Infinite loop, not stack overflow

That will avoid the SystemStackError error if the recursive call is at the end of the method and only the method. Of course, this example will result in an infinite loop instead. Probably best to debug using shallow recursion (and no optimization) before going after deep recursion.