some random bits and bytes…

Today I found an interesting way to improve the performance of recombination operators for my thesis project. Most of the operators work on arrays and copy elements of one array to another.

Not being a native Ruby speaker since day one, I initially implemented this behaviour using loops (#times & #upto). What I came up with was something like:

def use_times(foo, bar)
	500.times { |index| foo[index] = bar[index] }
	501.upto(1000) { |index| bar[index] = foo[index] }
end

While refactoring the code I changed it to use Ruby’s ranges. I did this because I thought they look better (code becomes easier to understand) than my loops. What I ended up with was something like:

def use_ranges(foo, bar)
	first_range = 0..500
	second_range = 501..1000
	foo[first_range] = bar[first_range]
	bar[second_range] = foo[second_range]
end

Of course you should never trust your own source code, so I ran my test cases and wrote a little benchmark like this:

require 'benchmark'

foo = Array.new(1000)
foo.map! { |gene| true }

bar = Array.new(1000)
bar.map! { |gene| false }

timing = Benchmark.measure do
    10000.times { use_times(foo, bar) }
end
puts "Running using #times took:\n#{timing}"

timing = Benchmark.measure do
    10000.times { use_ranges(foo, bar) }
end
puts "Running using ranges took:\n#{timing}"

Results of the Benchmark (user, system, total, real in seconds):

Running using #times took:
  2.692000   0.000000   2.692000 (  2.669000)

Running using ranges took:
  0.206000   0.000000   0.206000 (  0.206000)

After I saw the results I was impressed by the performance gain of such a little change. The new code runs 10-100 times faster than before, depending on the array size (and the size of the ranges).

I think the explanation for the behaviour is simply the possibility to use memcpy (in the implementation of Ruby) instead of a loop. An assignment using Ranges is just easier to optimize by the Ruby interpreter.