#require 'pry'

require 'yaml'

# DO NOT EDIT following list to temporarily run one benchmark for testing.

# You can run it by:

#

#   rake <bench>

#

# for instance:

#

#   rake Jasper

#

# alternatively, to run just stx:libjava version, run it by:

#

#   ./benchmark-runner.st -b Jasper -n 1

#

TESTS = [   

        # Order matters! 

        # Micro...

        [ "Ackerman" ,             8         ] ,

        [ "Ary" ,                  100000    ] ,        

        [ "Hash" ,                 10000     ] ,

        [ "Strcat" ,               5000000   ] ,

        [ "Native1" ,              1000000   ] ,

        # Macro...

        [ "Groovy" ,               5         ] ,

        [ "Saxon" ,                10        ] ,

        # [ "Jasper" ,               1 ] ,

        # Interop...        

        [ "MethodInvocation" ,     500000000 ] ,

        [ "PrimitiveArguments" ,   100000000 ] ,

        [ "ObjectArguments" ,      100000000 ] ,

        [ "WrappedArguments" ,     100000000 ] ,

        [ "OverloadedMethods2" ,   100000000 ] ,

        [ "OverloadedMethods" ,    100000000 ] ,

        # Broken 

        # [ "CrossLanguageInvocation" ,  500000000 ] ,

        # [ "Threadring" ,           100000 ] ,

        [] # terminator, to make commenting tests easy!!!

        ]

RESULTS_LAST="result.txt"

RESULTS_LAST_CSV="result.csv"

RESULTS_LOG="results-log.txt"

# Make sure it is 32bit JVM!!!

JAVA_HOME=ENV['JAVA_HOME'] || "/usr/lib/jvm/java-1.6.0-openjdk-i386"

JAVA="#{JAVA_HOME}/bin/java"

# Defines how many times given benchmark is run. The minimal value

# is then taken. 

BENCHMARK_RUNS=Integer(ENV["RUNS"] || "5")

task :default => [:all]

task :all => [:compile, :run]

task :build => [ :compile ]

task :compile do  

    Dir.chdir 'java' do 

        system 'ant'    

    end

end

task 'echo-classpath' do

        puts "export CLASSPATH=#{classpath()}"

end

task :clean do

    Dir.chdir 'java' do 

        system 'ant clean'    

    end  

    rm_f RESULTS_LAST

end

task :run do

  results = Hash.new

  TESTS.each do | spec |

    if spec.size == 2      

      benchmark(spec[0], spec[1], results, BENCHMARK_RUNS)  

    end      

  end

  results = Hash[results.sort]

  write_results_txt(STDOUT, results)  

  if File.exist? RESULTS_LAST

    File.delete(RESULTS_LAST)

  end

  if File.exist? RESULTS_LAST_CSV

    File.delete(RESULTS_LAST_CSV)

  end

  write_results_txt_to_file(RESULTS_LAST, results)

  write_results_csv_to_file(RESULTS_LAST_CSV, results)

  write_results_txt_to_file(RESULTS_LOG, results)  

end

# Generate tasks to run individual benchmarks

TESTS.each do | spec |

  if (spec.size == 2)

    task spec[0] do        

      results = Hash.new

      benchmark(spec[0], spec[1], results, BENCHMARK_RUNS)

      puts results.to_yaml

      write_results_txt(STDOUT, results)

    end

  end

end

# Run given benchmark

def benchmark(test, passes, results, runs)

    puts "Benchmarking #{test} (#{runs} passes)"      

    times = Hash.new

    puts "export CLASSPATH=#{classpath()}"

    ENV['CLASSPATH'] = classpath()

    [:jvm, :jvmint, :stx, :libjava, :libjavaint, :stx2libjava, :ruby].each do | platform |        

        times[platform] = measure(test, passes, platform, runs)

    end

    results[test] = times

end

# Return a class path arguments to be passed to java/javac

# (including '-cp') or an empty string

def classpath()

   return '/usr/share/java/groovy-all.jar:../libs/libs/saxon-9.1.0.8.jar:/usr/share/java/saxonb-9.1.0.8.jar:/usr/share/java/itext-2.1.7.jar:/usr/share/java/jasperreports.jar:/usr/share/java/commons-digester.jar:/usr/share/java/commons-logging.jar:/usr/share/java/commons-collections3.jar:/usr/share/java/commons-beanutils.jar:java/bin:.'

end

def measure(test, passes, platform, runs)

    min = 999999999

    i = 1;

    while (i <= runs)

        puts "Pass #{i}"

        t = measure_single(test, passes, platform)        

        if (t == 'N/A')

            min = t

            break;

        end

        if (min > t)

            min = t

        end

        i = i + 1

    end

    return min

end

# Runs a given bench on given platform and return the time. 

# If bench fails (non-zero status value), raise an exception. 

def measure_single(test, passes, platform)

       if (platform == :'jvm') 

          command = "#{JAVA} stx.libjava.benchmarks.#{test} #{passes}" 

       elsif (platform == :'jvmint') 

          command = "#{JAVA} -Xint stx.libjava.benchmarks.#{test} #{passes}" 

          command = 'echo "EXECUTION TIME: N/A"'

       elsif (platform == :'stx')

          command = "./benchmark-runner.sh --smalltalk -b #{test} -n #{passes} 2>&1"

       elsif (platform == :'libjava') 

          command = "./benchmark-runner.sh --jit --java -b #{test} -n #{passes} 2>&1"

       elsif (platform == :'libjavaint') 

          if test == 'Ackerman' 

            command = 'echo "EXECUTION TIME: N/A"'

          else 

            command = "./benchmark-runner.sh --nojit --java -b #{test} -n #{passes} 2>&1"

            command = 'echo "EXECUTION TIME: N/A"'

          end

       elsif (platform == :'stx2libjava') 

          command = "./benchmark-runner.sh --smalltalk2java -b #{test} -n #{passes} 2>&1"

       elsif (platform == :ruby)

          command = "./#{test.downcase}.rb #{passes} 2>&1"

       else

          raise Exception.new("Unssuported platform: #{platform}")          

       end

       puts " running: #{command}"

       output = `#{command}`

       if ($? != 0) 

           puts output

           raise Exception.new("Command failed!")

       end

       execution_time = (output.scan /^EXECUTION TIME: N\/A/).last()

       if execution_time 

          puts "      =>  N/A"

          return "N/A"

       end

       execution_time = (output.scan /^EXECUTION TIME: \d*[\.\d]\d*$/).last()

       execution_time = execution_time.gsub /^EXECUTION TIME: /, ''

       puts "      =>  #{execution_time}"

       return execution_time.to_i

end

def write_results_txt_to_file(filename, results)

  File.open(filename, "a+") do |file| 

    write_results_txt(file, results)

  end

end

def write_results_txt(file, results)   

    file.write("\n")

    file.write(Time.now.to_s)    

    file.write("\n")

    values = [[ "Test", "JVM", "JVM (int)", "STX-S", "STX-J", "STX-J (int)" , "STX-J2S", "Ruby" ]]

    TESTS.each do | pair |

      if (pair.size == 2) 

        key = pair[0]

        if (results.has_key? key)

          values << [ key, results[key][:jvm], results[key][:jvmint], results[key][:stx], results[key][:libjava], results[key][:libjavaint], results[key][:stx2libjava], results[key][:ruby] ]

        end

      end  

    end

    max_lengths = values[0].map { |val| val.length }

    values.each do |row|

      row.each_with_index do |elem, index|

        elem_size = elem.size

        max_lengths[index] = elem_size if elem_size > max_lengths[index]

      end

    end

    values.each do |val|

      format = max_lengths.map { |length| "%#{length}s" }.join(" " * 3)

      file.write(format % val)

      file.write("\n")

    end 

    file.write("--\n")

end        

def write_results_csv_to_file(filename, results)

  File.open(filename, "a+") do |file| 

    write_results_csv(file, results)

  end

end

def write_results_csv(file, results)   

    values = [[ "Test", "JVM", "JVM (int)", "STX-S", "STX-J", "STX-J (int)" , "STX-J2S", "Ruby" ]]

    TESTS.each do | pair |

      if (pair.size == 2) 

        key = pair[0]

        if (results.has_key? key)

          values << [ key, results[key][:jvm], results[key][:jvmint], results[key][:stx], results[key][:libjava], results[key][:libjavaint], results[key][:stx2libjava], results[key][:ruby] ]

        end

      end  

    end

    max_lengths = values[0].map { |val| val.length }

    values.each do |row|

      row.each_with_index do |elem, index|

        elem_size = elem.size

        max_lengths[index] = elem_size if elem_size > max_lengths[index]

      end

    end

    values.each do |val|

      format = max_lengths.map { |length| "%#{length}s , " }.join(" " * 3)

      file.write(format % val)

      file.write("\n")

    end 

end