In a previous article I took an example of bad metaprogramming and I pushed people to think twice before using metaprogramming.
My main points were that:
- you might make your code way slower if you don’t know what you are doing
- readability might drop considerably
- maintainability can become an issue
People left some very good comments about how to write the same module using metaprogramming and keep things fast.
Today Wycats pinged me about this post and told me that the issue was definemethod and that classeval is effectively the same as regular code, it gets evaluated in eval.c, just like regular Ruby code. On the other hand, defined_method has to marshall the proc.
I cleaned up my benchmarks using rbench, added some of the solutions provided to me and obtained the following results:
Here is the original/bad metaprogramming example:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
module MetaTimeDSL {:second => 1, :minute => 60, :hour => 3600, :day => [24,:hours], :week => [7,:days], :month => [30,:days], :year => [364.25, :days]}.each do |meth, amount| define_method "#{meth}" do amount = amount.is_a?(Array) ? amount[0].send(amount[1]) : amount self * amount end alias_method "#{meth}s".intern, "#{meth}" end end Numeric.send :include, MetaTimeDSL |
The no metaprogramming module is available there
Refactored:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
module RefaMetaTimeDSL {:second => 1, :minute => 60, :hour => 3600, :day => [24,:hours], :week => [7,:days], :month => [30,:days], :year => [364.25, :days]}.each do |meth, amount| self.class_eval <<-RUBY def r_#{meth} #{amount.is_a?(Array) ? "#{amount[0]}.#{amount[1]}" : "#{amount}"} end alias_method :r_#{meth}s, :r_#{meth} RUBY end end Numeric.send :include, RefaMetaTimeDSL |
the refactor 2 or eval based solution provided by Matt Jones which uses class_eval like the previous refactor.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
module EvalMetaTimeDSL def self.included(base) base.class_eval do [ [:e_second, 1], [:e_minute, 60], [:e_hour, 3600], [:e_day, [24,:e_hours]], [:e_week, [7,:e_days]], [:e_month, [30,:e_days]], [:e_year, [365.25, :e_days]]].each do |meth, amount| amount = amount.is_a?(Array) ? amount[0].send(amount[1]) : amount eval "def #{meth}; self*#{amount}; end" alias_method "#{meth}s", meth end end end end Numeric.send :include, EvalMetaTimeDSL |
and finally, the “better metaprogramming” version:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
module GoodMetaTimeDSL SECOND = 1 MINUTE = SECOND * 60 HOUR = MINUTE * 60 DAY = HOUR * 24 WEEK = DAY * 7 MONTH = DAY * 30 YEAR = DAY * 364.25 %w[SECOND MINUTE HOUR DAY WEEK MONTH YEAR].each do |const_name| meth = const_name.downcase class_eval <<-RUBY def g_#{meth} self * #{const_name} end alias g_#{meth}s g_#{meth} RUBY end end Numeric.send :include, GoodMetaTimeDSL |
Looking at the refactored version by Wycats, you can see he’s right and the major issue with the original version was definemethod. Using classeval does make things almost as fast and even faster than the no metaprogramming version.
Interesting enough, the benchmarks show that some methods from the meta modules are faster than the ones from the no meta module. Overall, an optimized metaprogramming can be more or else as fast as a non meta code. Of course, with the new VMs coming up, things might change a little bit depending on the language implementation.
In conclusion, metaprogramming can be as fast as no metaprogramming but that won’t help your code readability and maintainability, so make sure to only use this great trick when needed!
p.s: here is the benchmark file if you don’t believe me 
