Ruby Garbage Collection: Still Not Ready for Production

http://www.omniref.com/blog/blog/2014/03/27/ruby-garbage-collection-still-not-ready-for-production/

by timr • 12 years ago

169 108 12 years ago

noelwelsh• 12 years ago

Why not use the JVM (e.g. JRuby)? These problems have long been solved (if they ever occurred to start with.)

rubiquity8• 12 years ago

I think a lot of Rubyists unfortunately don't write thread safe code :( I've worked on many Rails apps that have some mutable state on the ApplicationController and the models. Also, developing on the JVM requires a change in tooling that a lot of Rubyists aren't used to, as well as the slow JVM start up times which can make TDD with JRuby a pain. JRuby is consistently getting better, though.

mbillie1• 12 years ago

mutable state on the ApplicationController and the models

Well, mutable state on the models seems pretty fair, unless I'm misunderstanding you. It's rather unforgivable on ApplicationController though.

Edit: and the slow startup time doing TDD with JRuby was my primary complaint when I developed in it. Although iirc you can use nailgun or something to keep the JVM active and mitigate that pain.

Twirrim• 12 years ago

Is the JRuby environment sufficiently different that you can't TDD against MRI and then save JRuby for final validation testing and deployment? They shouldn't be that different, unless you're not writing pure ruby code.

Alternatively, Nailgun should reduce a lot of that pain. Effectively you have a running server instance of JVM and run some clients on it. That gives you JVM speed advantages without the slow startup. JRuby natively supports it: https://github.com/jruby/jruby/wiki/JRubyWithNailgun

r4um• 12 years ago

Exactly. Jruby warbler rocks, create easily deployable artifacts jars, wars etc and you have rock solid JVM at your disposal.

gdeglin• 12 years ago

http://www.isrubyfastyet.com/ seems to show that Rails+JRuby performance remains disappointingly bad. The memory usage is kind of nuts too, not sure why it's so high.

Edit:

This page explains the high memory usage and it seems more reasonable now: https://github.com/jruby/jruby/wiki/Troubleshooting-Memory-U...

RyanZAG• 12 years ago

I think this would be a better benchmark than that one as it runs a more apples-apples comparison:

http://www.techempower.com/benchmarks/#section=data-r8&hw=i7...

teacup503• 12 years ago

These benchmarks are uselessly bad:

- The client connections are run without concurrency, serially, on the same machine: https://github.com/brianhempel/isrubyfastyet/blob/master/run...

- The JIT is only given 3 seconds to warm up: https://github.com/brianhempel/isrubyfastyet/blob/master/run... -- HotSpot kicks ass, but not after only 3 seconds of serially issued requests.

- By running the tests single-threaded, they're throwing away one of the major wins of the JVM -- low overhead concurrency.

joevandyk• 12 years ago

Slow startup time for large ruby applications.

Legion• 12 years ago

you are using Unicorn, right? You should be!

No. http://puma.io/

derwiki2• 12 years ago

Are these numbers still accurate?

http://ylan.segal-family.com/blog/2013/05/20/unicorn-vs-puma...

At any rate, Unicorn would still be better than the default Heroku server.

fomb• 12 years ago

There is no 'default' Heroku server on Cedar, it runs what your app asks to run. If that's Thin you'll be running on Thin. However, Heroku recommend Unicorn.

thinkbohemian5• 12 years ago

the default Heroku server

There is no "default Heroku server" you get exactly what you specify. If you specify nothing you get what Rails runs by default which is webrick and happens to be awful in production. It's not that "Heroku has a bad default" here but rather Rails' default web server is not intended to run in Production. Most of our docs try to emphasize that you should be using another server other than webrick. Some people want to just bang out a proof of concept and not worry about configuring Puma or Unicorn, for them webrick is fine.

thinkbohemian5• 12 years ago

Heroku Ruby guy here. I recommend Puma. Especially if your app is threadsafe. Even if it isn't you can still run multiple workers and only one thread and you get protection against slow clients (that Unicorn doesn't have). https://devcenter.heroku.com/articles/deploying-rails-applic...

I also wrote this gem that tunes the number of Puma workers and resets any workers where a memory leak is detected: http://github.com/schneems/puma_auto_tune

rubiquity8• 12 years ago

I admire your recent work with threads in Ruby with the Puma libraries and the threaded in memory queue (I was working on something similar myself, I keep forgetting to get back to it though). Most companies I see using Heroku are always wondering if their bill could be lower and most of the time they are using preforking servers and background job processors.

I look forward to your talk at Ancient City Ruby next week!

jamesharker2• 12 years ago

Wow, this is awesome. You should add a link to the Puma guide [1] as I've been wanting to make use of Puma workers for a while but have always been worried about running out of memory.

[1] https://devcenter.heroku.com/articles/deploying-rails-applic...

wasd• 12 years ago

Any idea why the docs[1] recommend using Unicorn instead?

On Cedar, we recommend Unicorn as the webserver. Regardless of the webserver you choose, production apps should always specify the webserver explicitly in the Procfile.

[1] https://devcenter.heroku.com/articles/ruby-support#rails-4-x...

mikewhy• 12 years ago

Puma really is great. I was floored by the performance gains compared to two unicorn workers.

bnferguson• 12 years ago

Unsure how it is these days, but sometime back there were pretty huge issues with the rolling restart function (cluster mode pretty much didn't work, and would cause downtime) and UNIX socket handling in Puma (would hold onto sockets, would have to login to servers to clear the issue). This caused a decent bit of downtime on occasions.

I would expect these to be fixed by now, and for certain setups it simply wouldn't be an issue, but definitely put a bit caveat in "Use Puma!"

Performance wise we saw it actually be worse than Unicorn at my former company. There were a few issues but the biggest one was no out of band GC at the time, so GC time was part of the requests and something a user saw. There were some use cases where it should have destroyed Unicorn but still strangely lagged (threaded, high IO operations. Should have been able to do far more with less since Puma continues to serve while Unicorn workers will wait). Memory usage did seem better.

We ended up back on Unicorn after a few weeks of fighting. I would imagine it to be better now (no longer deal with servers at all, so no idea), but I found the dissonance between everyone heaping love on Puma at the time and the actual experience jarring.

It seemed like a fantastic project, but at the time only for certain projects and certain infrastructure setups while Unicorn was fairly bulletproof.

Of course all of this is old knowledge and with the people who are involved in the project I expect things are far better these days. Caveat lector and such. :D

otterley6• 12 years ago

Why is Puma better than Unicorn?

cmbaus• 12 years ago

I have a question regarding the Puma architecture.

Does it use async/evented connection handling combined with a thread pool of workers handling requests?

rubiquity8• 12 years ago

(you are using Unicorn, right? You should be!)

No, you should be using Puma.[0] Unicorn is a work of art and it is incredibly simple, but with that comes a lot of waste. Puma won't fix this problem as it lies in MRI, but you will be able to run way less processes so total memory consumption won't be such an issue.

Ruby 2.1 comes with an asterisk. It's a lot faster but you should take some time to tune the GC to your application's needs. Aman Gupta[1] has some excellent posts on his blog about how to do this. On Rails apps that I have upgraded from 2.0 to 2.1 we have seen around 25% (and up to as high as 50% in some places) decrease in response times. The GC oddities will all certainly get better in Ruby 2.2 (and maybe even in minor releases of 2.1 but I doubt it).

0 - http://puma.io

1 - http://tmm1.net

nnq• 12 years ago

Why not Passenger?

rubiquity8• 12 years ago

I think Passenger only offers multi-threading in the enterprise edition.

midas0076• 12 years ago

Puma offers both multi-threading and multi-process in clustered mode to take advantage of multiple cores.

Here's our config/puma.rb that we used with Rails 4.1beta and 2.1.1: https://gist.github.com/9838767

otterley6• 12 years ago

"Unicorn is a work of art and it is incredibly simple, but with that comes a lot of waste."

What "waste" are you talking about? It's a multiprocess Rack-compliant webserver, and not much else.

FooBarWidget4• 12 years ago

Being multi-process is the "waste". Each process has its own heap, its own copy of the AST and bytecode, etc. Even with preforking and copy-on-write, the overhead introduced by processes is still significantly bigger than running many threads within 1 process.

Of course, this doesn't have to be a problem for everyone. Whether threads are advantageous depends a lot on the workload.

csfrancis• 12 years ago

Ruby 2.1.1 introduces a new environment variable, RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR, that helps to mitigate the heap growth caused by the generational garbage collector added in 2.1. By setting this variable to a value lower than the default of 2 (we are using the suggested value of 1.3) you can indirectly force the garbage collector to perform more major GCs, which reduces heap growth.

See https://bugs.ruby-lang.org/issues/9607 for more information.

gnufied• 12 years ago

This needs to be upvoted more. We went through similar pains when upgrading rather big app to Ruby 2.1.1 and setting RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR value to 1.3 did help reduce memory usage of Unicorn workes by almost 100MB.

I am not saying this is actual fix and I would like to hear from OP if he tried this environment variable and if it had any impact.

TL;DR New generational garbage collector of Ruby has some issues and ruby-core is working to fix it.

jamesharker2• 12 years ago

We're using this & found it works well at slowing down heap growth however we still end up with the same maximum memory usage as before, it just takes longer to get there.

timr2• 12 years ago

Yes, exactly. You're changing the slope of the growth, but the growth still happens.

x0x0• 12 years ago

stuff like this is why people use the jvm; at this point, it's pretty bulletproof

Fasebook2• 12 years ago

Gotta love those reflection api attacks and other remote procedure injections. Also, don't forget that everything is an object.

mavroprovato2• 12 years ago

Could you provide an example of those attacks/injections?

petersellers• 12 years ago

Also, don't forget that everything is an object.

This is false. What point are you trying to make here?

hawleyal• 12 years ago

lolwut

ori_b• 12 years ago

I haven't needed to maintain a production service using the JVM, but I've seen coworkers debug one where the service was producing too much garbage for the GC to keep up with, and then falling over with an OOM error.

No, using another language wouldn't have solved the issue. Modifying the code to reduce the amount of garbage produced was one of the solutions. Deleting the code not too long after was the ultimate solution.

purephase• 12 years ago

Another vote for puma. We're using Unicorn in our production environment right now with the unicorn-worker-killer gem, but our initial tests with ruby 2.1 and puma in dev/QA are going well so we're looking to move to that setup in the near future.

dcu• 12 years ago

a nice thing about unicorn is zero-downtime deployments, can you do that with puma?

projct• 12 years ago

Yep. https://www.digitalocean.com/community/articles/how-to-set-u...

FooBarWidget4• 12 years ago

Phusion Passenger author here.

The article mentions that Unicorn's out-of-band garbage collection is problematic because the way it works - running the GC after every request, and requiring turning off the normal GC - is overkill. But there the community is working on a better solution.

In particular, Aman Gupta described this very same problem and created a gem which improves out-of-band garbage collector, by only running it when it is actually necessary, and by not requiring one to turn off the normal GC. Phusion Passenger (even the open source version) already integrates with this improved out-of-band garbage collector through a configuration option. This all is described here: http://blog.phusion.nl/2014/01/31/phusion-passenger-now-supp...

Just one caveat: it's still a work in progress. There's currently 1 known bug open that needs reviewing.

Besides the GC stuff, Phusion Passenger also has a very nice feature called passenger_max_requests. It allows you to automatically restart a process after it has processed the given number of requests, thereby lowering its peak memory usage. As far as I know, Unicorn and Puma don't support this (at least not out of the box; whether there are third party tools for this, I don't know). And yes, this feature is in open source.

boundlessdreamz• 12 years ago

What's the known bug?

benesch• 12 years ago

The project appears to be called gctools: https://github.com/tmm1/gctools

And the known bug is probably "Allow dry-running the OOBGC": https://github.com/tmm1/gctools/pull/5

Without knowing anything about the project, it seems like the bug is particular to Passenger's use case.

FooBarWidget4• 12 years ago

https://github.com/FooBarWidget/gctools/pull/1

billrobertson42• 12 years ago

running the GC after every request, and requiring turning off the normal GC - is overkill.

Sort of reminiscent of Erlang's per-process GC. Although, given what I've seen of Ruby's internals, I'm sure the similarities stop at the very highest conceptual levels.

astrodust2• 12 years ago

Based on what I've seen in NodeJS, isn't it about time that Ruby has some kind of temporary "Buffer" class that represents data in a way intrinsically different from String?

This would allow explicit clearing of the data in a way that would break how String works, but in the context of Buffer it would be allowed.

If the Ruby GC isn't cutting it for you, maybe old-school memory management is the way to go, right?

phillmv2• 12 years ago

From the article, the issue is that the Ruby GC is triggered on total number of objects, and not total amount of used memory.

The article claims this got worse with the new generational GC algorithm, which sought to minimize the amount of work the GC has to do during the collection pause. By marking long lived objects as probably OK, you end up with fewer objects to free per GC cycle.

The problem then, is if you allocate some massive strings, and they get marked as "old" then they might never get collected by the GC. It's not clear to me if the article author sees it this way, but apparently there is some kind of bugs where some class of objects get marked "old" by accident, and it sounds like it's exacerbated by existing interpreter architecture.

Work on the Ruby interpreter is weirdly silo'ed off and mostly done by Japanese developers, so there's a significant barrier to entry for any enterprising C developer to roll her sleeves up and get hacking.

Anyhow, so, my understanding of your question is no, it would not help outside of really specific optimizations? It depends on what this Buffer class would do. Would they let you mark them as being young? Or avoid extra malloc calls because you have special information on the size of your strings? Kinda depends on how the generational algorithm was implemented? At this stage my knowledge grows thin.

stormbrew4• 12 years ago

There's nothing really stopping you from doing this with a cext or just using a String with all its encodings set to BINARY. I don't really see why it would be helpful here, though. The Ruby VM is essentially abdicating the difficulties of managing a large block heap to the platform's implementation, this wouldn't really change with a buffer class that could be similarly large.

dclowd9901• 12 years ago

Using ARC with Objective C has been an amazing experience, and I come from the brainless world of Javascript GC.

Any reason why more environments don't adopt this approach? It seems entirely efficient, reasonable and well-designed...

muaddirac• 12 years ago

I would suspect that it's because a ruby ARC would require thinking more about references (the strong/weak paradigm would, I think, need to come into play) which isn't really a concept in Ruby. I think it would be difficult to ensure code written without arc would still run properly.

But I agree with you. I much prefer ARC over any GC I've come into contact with.

ksec• 12 years ago

Well RubyMotion is using ARC.

dunham• 12 years ago

Python does reference counting.

The downside is that you can leak memory if you have circular references. The programmer needs to take care to not let this happen. (This is essentially the cause of the Javascript memory leaks in IE, although the reference counting only occurred at the boundary between Javascript objects and browser objects.)

I believe python handles this by occasionally running a garbage collector that looks for leaked objects.

Objective C offers weak pointers (pointers that "don't count" and zero themselves out when all the other pointers to the object disappear), which can aid a programmer in avoiding circular references.

Finally, I believe it has been shown that reference counting can be slower that a well-implemented garbage collector, but I suspect this depends on your specific workload.

berdario2• 12 years ago

Python also has weakrefs to avoid creating cycles

http://docs.python.org/3.4/library/weakref.html

nostrademons• 12 years ago

Reference counting is also the reason why Python requires a GIL. Incrementing a reference count is an opportunity for a race condition (another thread could read the refcount in between your read and write), which means that every reference count needs to be protected by a lock. Either you do fine-grained locking for each object, or you add a GIL for the whole interpreter. The former will absolutely kill performance (not only do you need to increment a refcount with every assignment or function call, you need to take a lock). The latter makes the whole interpreter thread-hostile.

deathanatos• 12 years ago

The downside is that you can leak memory if you have circular references. The programmer needs to take care to not let this happen.

Not entirely true[1]:

CPython currently uses a reference-counting scheme with (optional) delayed detection of cyclically linked garbage, which collects most objects as soon as they become unreachable, but is not guaranteed to collect garbage containing circular references.

The "most object" and "not guaranteed" refer to[2]:

Objects that have __del__() methods and are part of a reference cycle cause the entire reference cycle to be uncollectable, including objects not necessarily in the cycle but reachable only from it. Python doesn’t collect such cycles automatically because, in general, it isn’t possible for Python to guess a safe order in which to run the __del__() methods. If you know a safe order, you can force the issue by examining the garbage list, and explicitly breaking cycles due to your objects within the list.

Note that this is Python 2 thing; in Python 3, the behavior has changed, and cycles with __del__ methods get collected. I include it because many people still use Python 2. As for Python 2, however, I believe this case is rare, and requires both an object to be involved in a cycle (a bit rare) and have a __del__ method (I've never written such a method in many years of Python).

Objective C offers weak pointers

Python also offers weak pointers.

Finally, I believe it has been shown that reference counting can be slower that a well-implemented garbage collector

My understanding is that this is true, but workload dependent. I think this mostly comes from being able to quickly allocate memory, because your heap is just allocating by moving a pointer the required number of bytes through the heap. (Allocation is just an addition, mostly.) When a collection happens, objects not collected move to a different heap (the next generation), and the heap used for allocation is emptied out. The amount of work and moving depends on the number of objects remaining, which tends to be low, since objects are short lived.

The advantage to pure refcounting, in languages such as C++, is that collection is deterministic. In the rare case that you have a cycle, then you do have to handle it manually (that's the tradeoff), but I find these are extremely rare. Memory management in modern C++ is a non-issue most of the time. And prevents bugs like:

  data = open(filename, 'rb').read()

I see this bug far too often. One could argue that in Python, it'll get collected via refcount, but this isn't guaranteed by the language. I've seen the same bug in Java/C# code, and there are no refcounts to save you there. (Of course, these languages have a with/using/etc. block, and it's an easy fix, yet nonetheless, these bugs are frequent.)

  [1]: http://docs.python.org/2.7/reference/datamodel.html#objects-values-and-types
  [2]: http://docs.python.org/2/library/gc.html

wbl• 12 years ago

Performance suffers. Every write requires an adjustment to an object's reference count, and if you have objects that can be cross-thread an atomic test-set at that. The underlying allocator has to deal with fragmentation, because there is no copying. Furthermore, every object grows a count field.

rubyn00bie• 12 years ago

Oh Unicorn... a little GC tuning goes a long way, and isn't that hard... For most apps the time spent in GC, while annoying, is far and away not the bottleneck.

... especially since Ruby 2.0 as the GC is much, much faster.

I'll be honest, I don't think the memory bloat is that problematic if you design the app well (business logic definitely prevents this some time)... but in general you can pass most of that off to a background worker, or pre-cache responses so you aren't bloating your app server instances/threads.

znowi• 12 years ago

Whenever I read that "you should be using X", credibility of the author rapidly diminishes for me.

iancarroll• 12 years ago

Ha, so Unicorn did have a bug in it.

I thought it was me.

jrochkind1• 12 years ago

Seems like a reason to stick to ruby 2.0 and not upgrade to 2.1, no?

sams993• 12 years ago

This article enrages me.

I totally agree with codinghorror that a blog without comments in not a blog, this is a prime example. No way to respond to the author without jumping through crazy hoops.

As to the issue.

1. NEVER use unicorn oobgc that ships with unicorn or the old one that ships with passenger. Use gctools on 2.1.1 https://github.com/tmm1/gctools or this on 2.0 http://samsaffron.com/archive/2013/11/22/demystifying-the-ru.... If you are disabling GC you are doing it wrong and creating rogue processes.

2. Expect memory doubling with Ruby 2.1.1. Not happy with that? You have 2 options. Tune it down by reducing RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR. At 1 your memory consumption will be on par with 2.0. It ships with the 2 default. Option 2, wait for a future release of Ruby, this will be fixed in 2.2 maybe even patched a bit more in 2.1.2 . See: https://bugs.ruby-lang.org/issues/9607 and http://vimeo.com/89491942 and https://speakerdeck.com/samsaffron/why-ruby-2-dot-1-excites-...

As for the, full-of-bait, title. Ruby's GC is ready for production and being used in production in plenty of places. Just don't go expecting rainbows if you disable it. And expect memory doubling with 2.1.1 if left untuned. You can choose how much you want the memory to increase from 2.0

timr2• 12 years ago

OK, I'll bite.

First, sorry we don't have comments yet. I'm the author, so you no longer have to be enraged. Perhaps just annoyed.

Second, with Ruby 2.1, out of the box, this code:

   while true do 
    "a" * (1024 ** 2)
   end

leads to infinite process growth. There should be no need for "memory doubling" to run this code -- you're generating throwaway strings of identical size. Similar code, in other languages, does not lead to out of control memory consumption.

Also, the problem isn't caused by disabling the GC. This happens in stock Ruby 2.1. Disabling the GC (and running it once per request) is the fix for the problem.

vidarh• 12 years ago

There should be no need for "memory doubling" to run this code -- you're generating throwaway strings of identical size.

How do you know they are throwaway?

Your code involves two method calls. While it would be unlikely that someone has overridden them given that they are core String and Fixnum methods, it is perfectly possible. E.g:

  class String;

    alias :old :*

    def * right
      $store ||= []
      $store << self
      old(right)
    end
  end


  "foo" * 5
  "bar" * 3

  p $store

In other words, even with seemingly innocent calls like that, it takes extra work to be able to reuse that memory without a full GC pass. It's certainly not impossible, but it's not there yet.

So I agree with you in principle, but this is one of those areas where the malleability of Ruby objects makes it tricky to optimize.

(one possible example approach is to set aside a bit to indicate "has at least once been stored somewhere where it can escape" as "poor mans escape analysis" - if your object is only ever stored in local variables that have no been captured by a lambda, or passed as arguments, then it can't escape higher than where it was created, and so you can take shortcuts, otherwise you'd still need a full gc pass)

sams993• 12 years ago

That sir, is a bug that should be reported on bugs.ruby-lang

   while true do 
    "a" * (1024 ** 2)
   end

it is to do with the dynamic malloc limit growing too much, should be fairly trivial to patch in the next 2.1 release

bqe• 12 years ago

Okay, about blogs without comments:

My blog doesn't have a comment section. It's because I sometimes post controversial opinions and I don't want the garbage that often pollutes comment sections ending up permanently attached to my writing. You can't delete overly negative comments without seeming like a fascist, so what do you do?

I prefer to submit my posts to HN or other sites where people can comment and not have their comments permanently attached.

As for Jeff Atwood's comparison of a blog without comments to a pulpit, that's ridiculous. Does he also hate books and essays? My blog is simply a collection of essays.

jafaku• 12 years ago

Seems like Rubysts spent too much time bashing PHP and very little time improving their language, and now they have been left behind.

sayrer• 12 years ago

Doesn't Ruby need to break compatibility with its C API to get a good result here?

To get a copying, generational GC as in Java, it would need to stop handing out raw pointers.

ptx• 12 years ago

Couldn't this problem be largely solved the same way C# does it, with its GC.AddMemoryPressure function? If you're using lots of unmanaged memory, you simply inform the GC when you're allocating and freeing it, so that in can be taken into account.

http://msdn.microsoft.com/en-us/library/system.gc.addmemoryp...

Ruby Garbage Collection: Still Not Ready for Production

Related Stories