Reynholm Industries

As some of you know my current job makes me program in Ruby thing that I have to say I like, mostly cause sometimes you find interesting facts like the one I will write about here.

Yesterday, together with my college Adolfo Builes, we had an interesting ongoing discussion about the performance of the map operation, specially in some use cases we face with.

You can check the code I used to benchmark this operation obviously on github, and obviously try to reproduce it. And please all the statements I make here are based on this numbers and my experiences, comments are really welcome!.

So lets check my thoughts about this operation. Before start with the numeric analysis I would love talk a bit about the methodology I followed.

We faces with the use case where we want to use a map operation, over an ruby enumerable, with the main business of tuning this collection with new data useful as an output of the function. So after a long time debugging we discovered that the most important batch of time was used by the map operation.

So I tried to compare this situation using the next configuration:

• JRuby 1.6.3.
• Ruby versions 1.8 and 1.9.
• Having the collection in memory or not.
• Using a custom class with lots of data and Fixnum as the tiny one.

So for this I used the ruby standard library benchmarking facilities, specially the Benchmark.bm and Benchmark.bmbm modes, and a MacBook Pro as a test machine. It is important to notice that all the executions where made using the default JRuby configuration options.

And obviously after that there came some interesting insights I think important to share with you:

• As a general fact, using the map function with bloc as a parameter, its quite more faster than using the method symbol as a single argument. This seems to be well known for the ruby community since a long time. I think has an argument when you think how the procedures are managed into the ruby compiler.
• Either you use 1.8 or 1.9, and your data is not simple and also more likely not to be always in memory, it is better to avoid using map. It performs a lot better to use your custom code. Really would love to understand why? will look deeper on how the JRuby implementation of this function looks like.
• But if your data is simple, using map with a bloc as a parameter is your best shot. And the custom mapping the worst. Think this could be related with the memory assigned to the JRuby heap, but also need more in deep knowledge in order to understand it at all.
• If your data is going to be most of the time in memory, other facts need to be take it into account:
• • Using map with a bloc parameter looks to be the best shot either using 1.8 or 1.9 modes, when talking about complex objects.
  • Also mapping data throw a your custom code looks not to be the best shoot, however in the 1.9 mode is better than using map with a symbol parameter.
  • But when talking about the tiny ones, using map with a symbol parameter always succeed as the best one.

Obviously this can not be take it 100% seriously as I am too new to the ruby world, but its interesting how the same function performs in different ruby versions, and processed data. Would love anyone with more experience in the language to share your opinion about, also all the ruby programming tips are really welcome!

Next steeps try to discover why this functions is performing like this in different scenarios, moving from the number to the real knowledge of the causes!

Keep on!

- purbon