Redmine

require "benchmark"

STATUS_COUNTS = [10, 20, 40, 80].freeze

TRACKER_IDS = [1].freeze

ROLE_IDS = [1].freeze

ITERATIONS = 5

def build_status_ids(count)

  (100_000..(100_000 + count - 1)).to_a

end

def build_transitions(status_ids)

  status_ids.each_with_object({}) do |old_status_id, transitions|

    transitions[old_status_id.to_s] =

      status_ids.each_with_object({}) do |new_status_id, by_new_status|

        by_new_status[new_status_id.to_s] = {

          "always" => "1",

          "author" => "1",

          "assignee" => "1"

        }

      end

  end

end

def seed_records!(status_ids, tracker_ids, role_ids)

  rows = []

  tracker_ids.each do |tracker_id|

    role_ids.each do |role_id|

      status_ids.each do |old_status_id|

        status_ids.each do |new_status_id|

          rows << {

            :tracker_id => tracker_id,

            :role_id => role_id,

            :old_status_id => old_status_id,

            :new_status_id => new_status_id,

            :author => false,

            :assignee => false

          }

          rows << {

            :tracker_id => tracker_id,

            :role_id => role_id,

            :old_status_id => old_status_id,

            :new_status_id => new_status_id,

            :author => false,

            :assignee => true

          }

        end

      end

    end

  end

  WorkflowTransition.insert_all!(rows)

end

def delete_seed_records!(status_ids, tracker_ids, role_ids)

  WorkflowTransition.where(

    :tracker_id => tracker_ids,

    :role_id => role_ids,

    :old_status_id => status_ids,

    :new_status_id => status_ids

  ).delete_all

end

def original_replace_transitions(trackers, roles, transitions)

  trackers = Array.wrap(trackers)

  roles = Array.wrap(roles)

  WorkflowTransition.transaction do

    records = WorkflowTransition.where(:tracker_id => trackers.map(&:id), :role_id => roles.map(&:id)).to_a

    transitions.each do |old_status_id, transitions_by_new_status|

      transitions_by_new_status.each do |new_status_id, transition_by_rule|

        transition_by_rule.each do |rule, transition|

          trackers.each do |tracker|

            roles.each do |role|

              w = records.select do |r|

                r.old_status_id == old_status_id.to_i &&

                  r.new_status_id == new_status_id.to_i &&

                  r.tracker_id == tracker.id &&

                  r.role_id == role.id &&

                  !r.destroyed?

              end

              if rule == "always"

                w = w.select {|r| !r.author && !r.assignee}

              else

                w = w.select {|r| r.author || r.assignee}

              end

              if w.size > 1

                w[1..-1].each(&:destroy)

              end

              w = w.first

              if ["1", true].include?(transition)

                unless w

                  w = WorkflowTransition.new(

                    :old_status_id => old_status_id,

                    :new_status_id => new_status_id,

                    :tracker_id => tracker.id,

                    :role_id => role.id

                  )

                  records << w

                end

                w.author = true if rule == "author"

                w.assignee = true if rule == "assignee"

                w.save if w.changed?

              elsif w

                if rule == "always"

                  w.destroy

                elsif rule == "author"

                  if w.assignee

                    w.author = false

                    w.save if w.changed?

                  else

                    w.destroy

                  end

                elsif rule == "assignee"

                  if w.author

                    w.assignee = false

                    w.save if w.changed?

                  else

                    w.destroy

                  end

                end

              end

            end

          end

        end

      end

    end

  end

end

def benchmark_variant(status_ids)

  tracker = Tracker.find(TRACKER_IDS.first)

  role = Role.find(ROLE_IDS.first)

  transitions = build_transitions(status_ids)

  before_durations = []

  after_durations = []

  ITERATIONS.times do

    delete_seed_records!(status_ids, TRACKER_IDS, ROLE_IDS)

    seed_records!(status_ids, TRACKER_IDS, ROLE_IDS)

    before_durations << Benchmark.realtime { original_replace_transitions(tracker, role, transitions) }

    delete_seed_records!(status_ids, TRACKER_IDS, ROLE_IDS)

    seed_records!(status_ids, TRACKER_IDS, ROLE_IDS)

    after_durations << Benchmark.realtime { WorkflowTransition.replace_transitions(tracker, role, transitions) }

  ensure

    delete_seed_records!(status_ids, TRACKER_IDS, ROLE_IDS)

  end

  {

    :count => status_ids.size,

    :before_avg => before_durations.sum / before_durations.size,

    :after_avg => after_durations.sum / after_durations.size

  }

end

results = STATUS_COUNTS.map do |count|

  benchmark_variant(build_status_ids(count))

end

puts "| statuses | before_avg_s | after_avg_s | speedup | reduction |"

puts "| ---: | ---: | ---: | ---: | ---: |"

results.each do |result|

  speedup = result[:before_avg] / result[:after_avg]

  reduction = (1 - (result[:after_avg] / result[:before_avg])) * 100

  puts "| #{result[:count]} | #{format('%.4f', result[:before_avg])} | #{format('%.4f', result[:after_avg])} | #{format('%.2f', speedup)}x | #{format('%.1f', reduction)}% |"

end