app/services/tables/discomfort_calculator.rb

@@ -11,6 +11,7 @@ module Tables
     end
 
     def calculate
+      # Rails.logger.info "Calculating discomfort of table with id #{table.object_id}"
       breakdown.values.sum
     end
 

app/services/tables/distribution.rb

@@ -73,6 +73,8 @@ module Tables
 
     def local_discomfort(table)
       table.discomfort ||= DiscomfortCalculator.new(table:, hierarchy:).calculate
+      table.freeze
+      table.discomfort 
     end
   end
 end

app/services/tables/shift.rb

@@ -12,19 +12,37 @@ module Tables
     def each
       @initial_solution.tables.permutation(2) do |table_a, table_b|
         table_a.dup.each do |person|
-          original_discomfort_a = table_a.reset
-          original_discomfort_b = table_b.reset
+          
+          new_solution = Distribution.new(
+            min_per_table: @initial_solution.min_per_table,
+            max_per_table: @initial_solution.max_per_table,
+            hierarchy: @initial_solution.hierarchy
+          )
 
-          table_a.delete(person)
-          table_b << person
+          new_solution.tables = @initial_solution.tables.dup
 
-          yield(@initial_solution)
-        ensure
-          table_b.delete(person)
-          table_a << person
+          new_solution.tables.delete(table_a)
+          new_solution.tables.delete(table_b)
 
-          table_a.discomfort = original_discomfort_a
-          table_b.discomfort = original_discomfort_b
+          modified_table_a = table_a.dup.tap(&:reset)
+          modified_table_b = table_b.dup.tap(&:reset)
+
+          new_solution.tables << modified_table_a
+          new_solution.tables << modified_table_b
+
+          # original_discomfort_a = table_a.reset
+          # original_discomfort_b = table_b.reset
+
+          modified_table_a.delete(person)
+          modified_table_b << person
+
+          yield(new_solution)
+        # ensure
+        #   table_b.delete(person)
+        #   table_a << person
+
+        #   table_a.discomfort = original_discomfort_a
+        #   table_b.discomfort = original_discomfort_b
         end
       end
     end

app/services/tables/swap.rb

@@ -12,25 +12,45 @@ module Tables
     def each
       @initial_solution.tables.combination(2) do |table_a, table_b|
         table_a.to_a.product(table_b.to_a).each do |(person_a, person_b)|
-          original_discomfort_a = table_a.reset
-          original_discomfort_b = table_b.reset
+          
+          new_solution = Distribution.new(
+            min_per_table: @initial_solution.min_per_table,
+            max_per_table: @initial_solution.max_per_table,
+            hierarchy: @initial_solution.hierarchy
+          )
+          
+          new_solution.tables = @initial_solution.tables.dup
 
-          table_a.delete(person_a)
-          table_b.delete(person_b)
+          new_solution.tables.delete(table_a)
+          new_solution.tables.delete(table_b)
 
-          table_a << person_b
-          table_b << person_a
 
-          yield(@initial_solution)
-        ensure
-          table_a.delete(person_b)
-          table_b.delete(person_a)
+          modified_table_a = table_a.dup.tap(&:reset)
+          modified_table_b = table_b.dup.tap(&:reset)
 
-          table_a << person_a
-          table_b << person_b
+          new_solution.tables << modified_table_a
+          new_solution.tables << modified_table_b
 
-          table_a.discomfort = original_discomfort_a
-          table_b.discomfort = original_discomfort_b
+
+          # original_discomfort_a = table_a.reset
+          # original_discomfort_b = table_b.reset
+
+          modified_table_a.delete(person_a)
+          modified_table_b.delete(person_b)
+
+          modified_table_a << person_b
+          modified_table_b << person_a
+
+          yield(new_solution)
+        # ensure
+        #   table_a.delete(person_b)
+        #   table_b.delete(person_a)
+
+        #   table_a << person_a
+        #   table_b << person_b
+
+        #   table_a.discomfort = original_discomfort_a
+        #   table_b.discomfort = original_discomfort_b
         end
       end
     end

app/services/vns/engine.rb

@@ -20,7 +20,16 @@ module VNS
       @perturbations << klass
     end
 
-    attr_writer :initial_solution
+    def initialize_ractors(count: Concurrent.processor_count)
+      @ractors = count.times.map do |i|
+        Ractor.new(name: "VNS Ractor #{i}") do
+          # @target_function.call(Ractor.receive)
+          Ractor.receive.discomfort  # Hard-coded for now, should be dynamic
+        end
+      end.cycle
+    end
+
+    attr_writer :initial_solution, :ractors
 
     def run
       raise 'No target function defined' unless @target_function
@@ -30,6 +39,10 @@ module VNS
       @best_solution = @initial_solution
       @best_score = @target_function.call(@best_solution)
 
+      @best_solution.freeze
+      @best_solution.tables.freeze
+      # @best_solution.tables.each(&:freeze)
+
       self.class.sequence(@perturbations).each do |perturbation|
         optimize(perturbation)
       end
@@ -44,9 +57,27 @@ module VNS
         optimized = false
 
         perturbation_klass.new(@best_solution).each do |alternative_solution|
-          score = @target_function.call(alternative_solution)
+          # original_score =
+
+          # ractor = @ractors.next
+          # Rails.logger.info("Processed by ractor #{ractor.name}")
+
+          # ractor.send(alternative_solution)
+
+          # new_score = ractor.take
+
+          # binding.pry if new_score != original_score
+
+          # score = new_score
+
+          score =  @target_function.call(alternative_solution)
+
+          # Rails.logger.info("Evaluating alternative solution with score: #{score}")
+          
           next if score >= @best_score
 
+          # Rails.logger.info("Found better solution with score: #{score} (previous: #{@best_score})")
+
           @best_solution = alternative_solution.deep_dup
           @best_score = score
           optimized = true

lib/tasks/ractors.rake

@@ -0,0 +1,51 @@
+namespace :ractors do
+  desc 'Run the Ractors example'
+  task run: :environment do
+    list = (1..20)
+    number_of_ractors = Concurrent.processor_count
+
+    ractors = number_of_ractors.times.map do |i|
+      Ractor.new(name: "Ractor #{i}") do
+        loop do
+          number = Ractor.receive
+          puts "Processing #{number} in #{Ractor.current.name}"
+          Ractor.yield "eureka" if number == 17
+        end
+      end
+    end.cycle
+
+    list.each do |i|
+      ractors.next.send(i)
+    end
+
+    puts "all enqueued"
+
+    binding.pry
+
+    Ractor.select(*ractors)
+
+    # binding.pry
+
+    # number_of_ractors.times do |i|
+    #   r = Ractor.new(name: "Ractor #{i}") do
+    #     Ractor.receive.each do |i|
+    #       puts "Processing index #{i} in #{Ractor.current.name}"
+    #     end
+    #   end
+
+    #   r.send((i * 250)...((i + 1) * 250))
+    # end
+
+    # ractor = Ractor.new do
+    #   loop do
+    #     puts 'I will receive a message soon'
+    #     msg = Ractor.receive
+    #     puts 'I will return a tripple of what I receive'
+    #     Ractor.yield(msg * 3)
+    #   end
+    # end
+
+    # heavy_calculation.send(15)
+    # puts heavy_calculation.take
+  end
+end

lib/tasks/vns.rake

@@ -4,26 +4,47 @@ namespace :vns do
   desc 'Benchmarks the efficiency of the VNS implementation'
   task benchmark: :environment do
     ActsAsTenant.with_tenant(Wedding.first) do
-      Rails.logger.info "There are #{Guest.potential.count} potential guests"
 
-      engine = VNS::Engine.new
+      iterations = 10
 
-      engine.add_perturbation(Tables::Swap)
-      engine.add_perturbation(Tables::Shift)
+      guests = Guest.potential
+
+      Rails.logger.info "There are #{guests.count} potential guests"
+
+      time_acc = 0
+      solution_acc = 0
 
       hierarchy = AffinityGroupsHierarchy.new
-      initial_solution = Tables::Distribution.new(min_per_table: 8, max_per_table: 10, hierarchy:)
 
-      random = Random.new(561_163)
-      initial_solution.random_distribution(Guest.potential.shuffle(random:), random:)
+      iterations.times do |i|
+        engine = VNS::Engine.new
 
-      engine.initial_solution = initial_solution
+        engine.add_perturbation(Tables::Swap)
+        engine.add_perturbation(Tables::Shift)
 
-      engine.target_function(&:discomfort)
+        initial_solution = Tables::Distribution.new(min_per_table: 8, max_per_table: 10, hierarchy:)
 
-      solution = Rails.benchmark('VNS Benchmarking') { engine.run }
+        random = Random.new(i)
+        initial_solution.random_distribution(guests.shuffle(random:), random:)
 
-      Rails.logger.info "Best solution found with discomfort: #{solution.discomfort}"
+        engine.initial_solution = initial_solution
+
+        engine.target_function(&:discomfort)
+
+        start_time = Time.now
+        
+        solution = engine.run
+
+        elapsed = Time.now - start_time
+
+        time_acc += elapsed
+        solution_acc += solution.discomfort
+
+        Rails.logger.info "[#{elapsed}] Best solution found with discomfort: #{solution.discomfort}"
+      end
+
+      Rails.logger.info "Average time: #{time_acc / iterations} seconds"
+      Rails.logger.info "Average discomfort: #{solution_acc / iterations}"
     end
   end
 end