rubydb 0.1.4 → 0.1.6

data/lib/rubydb/concurrency/deadlock_detector.rb

@@ -1,150 +1,148 @@
-# frozen_string_literal: true
-
-require "set"
-
-module RubyDB
-  module Concurrency
-    # DeadlockDetector - Detects and resolves deadlocks
-    class DeadlockDetector
-      attr_reader :stats
-
-      def initialize(config = {})
-        @lock_graph = LockGraph.new
-        @deadlock_resolution = config[:resolution] || :abort_victim
-        @timeout = config[:timeout] || 30
-        @max_attempts = config[:max_attempts] || 3
-        @transaction_manager = config[:transaction_manager]
-        @stats = {
-          deadlocks_detected: 0,
-          deadlocks_resolved: 0,
-          victims_aborted: 0,
-          detection_runs: 0,
-          avg_detection_time_ms: 0,
-          total_detection_time_ms: 0
-        }
-        @lock = Mutex.new
-        @detection_thread = nil
-        @running = false
-      end
-
-      def start
-        @lock.synchronize do
-          return if @running
-
-          @running = true
-          @detection_thread = Thread.new do
-            detection_loop
-          end
-        end
-      end
-
-      def stop
-        @lock.synchronize do
-          @running = false
-          @detection_thread&.kill
-          @detection_thread = nil
-        end
-      end
-
-      def detect_deadlocks
-        @lock.synchronize do
-          @stats[:detection_runs] += 1
-          start_time = Time.now
-
-          # Build wait-for graph
-          @lock_graph.build
-
-          # Detect cycles
-          cycles = @lock_graph.detect_cycles
-
-          if cycles.any?
-            @stats[:deadlocks_detected] += cycles.size
-            cycles.each do |cycle|
-              resolve_deadlock(cycle)
-            end
-          end
-
-          detection_time = (Time.now - start_time) * 1000
-          @stats[:total_detection_time_ms] += detection_time
-          @stats[:avg_detection_time_ms] = @stats[:total_detection_time_ms] / @stats[:detection_runs]
-
-          cycles
-        end
-      end
-
-      def resolve_deadlock(cycle)
-        # Choose victim based on policy
-        victim = choose_victim(cycle)
-
-        if victim
-          abort_victim(victim)
-          @stats[:deadlocks_resolved] += 1
-          @stats[:victims_aborted] += 1
-        end
-
-        victim
-      end
-
-      def choose_victim(cycle)
-        # Choose the transaction with lowest priority or oldest timestamp
-        # For simplicity, choose the one with the most locks
-        cycle.max_by { |txn| txn[:locks] || 0 }
-      end
-
-      def abort_victim(victim)
-        victim[:aborted] = true
-        victim[:abort_time] = Time.now
-
-        if @transaction_manager.respond_to?(:get_transaction) &&
-            @transaction_manager.respond_to?(:rollback_transaction)
-          transaction = @transaction_manager.get_transaction(victim[:id])
-          @transaction_manager.rollback_transaction(transaction) if transaction
-        end
-
-        # Keep the graph in sync even when no transaction manager is attached.
-        @lock_graph.release_locks(victim[:id])
-      end
-
-      def add_lock_holder(resource, holder)
-        @lock.synchronize do
-          @lock_graph.add_holder(resource, holder)
-        end
-      end
-
-      def add_lock_waiter(resource, waiter)
-        @lock.synchronize do
-          @lock_graph.add_waiter(resource, waiter)
-        end
-      end
-
-      def remove_transaction(transaction_id)
-        @lock.synchronize do
-          @lock_graph.remove_transaction(transaction_id)
-        end
-      end
-
-      def stats
-        @lock.synchronize do
-          @stats.merge({
-            running: @running,
-            graph_size: @lock_graph.size,
-            graph_edges: @lock_graph.edge_count
-          })
-        end
-      end
-
-      private
-
-      def detection_loop
-        while @running
-          sleep(@timeout)
-          begin
-            detect_deadlocks
-          rescue => e
-            # Log error but continue
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Concurrency
+    # DeadlockDetector - Detects and resolves deadlocks
+    class DeadlockDetector
+      attr_reader :stats
+
+      def initialize(config = {})
+        @lock_graph = LockGraph.new
+        @deadlock_resolution = config[:resolution] || :abort_victim
+        @timeout = config[:timeout] || 30
+        @max_attempts = config[:max_attempts] || 3
+        @transaction_manager = config[:transaction_manager]
+        @stats = {
+          deadlocks_detected: 0,
+          deadlocks_resolved: 0,
+          victims_aborted: 0,
+          detection_runs: 0,
+          avg_detection_time_ms: 0,
+          total_detection_time_ms: 0
+        }
+        @lock = Mutex.new
+        @detection_thread = nil
+        @running = false
+      end
+
+      def start
+        @lock.synchronize do
+          return if @running
+
+          @running = true
+          @detection_thread = Thread.new do
+            detection_loop
+          end
+        end
+      end
+
+      def stop
+        @lock.synchronize do
+          @running = false
+          @detection_thread&.kill
+          @detection_thread = nil
+        end
+      end
+
+      def detect_deadlocks
+        @lock.synchronize do
+          @stats[:detection_runs] += 1
+          start_time = Time.now
+
+          # Build wait-for graph
+          @lock_graph.build
+
+          # Detect cycles
+          cycles = @lock_graph.detect_cycles
+
+          if cycles.any?
+            @stats[:deadlocks_detected] += cycles.size
+            cycles.each do |cycle|
+              resolve_deadlock(cycle)
+            end
+          end
+
+          detection_time = (Time.now - start_time) * 1000
+          @stats[:total_detection_time_ms] += detection_time
+          @stats[:avg_detection_time_ms] = @stats[:total_detection_time_ms] / @stats[:detection_runs]
+
+          cycles
+        end
+      end
+
+      def resolve_deadlock(cycle)
+        # Choose victim based on policy
+        victim = choose_victim(cycle)
+
+        if victim
+          abort_victim(victim)
+          @stats[:deadlocks_resolved] += 1
+          @stats[:victims_aborted] += 1
+        end
+
+        victim
+      end
+
+      def choose_victim(cycle)
+        # Choose the transaction with lowest priority or oldest timestamp
+        # For simplicity, choose the one with the most locks
+        cycle.max_by { |txn| txn[:locks] || 0 }
+      end
+
+      def abort_victim(victim)
+        victim[:aborted] = true
+        victim[:abort_time] = Time.now
+
+        if @transaction_manager.respond_to?(:get_transaction) &&
+            @transaction_manager.respond_to?(:rollback_transaction)
+          transaction = @transaction_manager.get_transaction(victim[:id])
+          @transaction_manager.rollback_transaction(transaction) if transaction
+        end
+
+        # Keep the graph in sync even when no transaction manager is attached.
+        @lock_graph.release_locks(victim[:id])
+      end
+
+      def add_lock_holder(resource, holder)
+        @lock.synchronize do
+          @lock_graph.add_holder(resource, holder)
+        end
+      end
+
+      def add_lock_waiter(resource, waiter)
+        @lock.synchronize do
+          @lock_graph.add_waiter(resource, waiter)
+        end
+      end
+
+      def remove_transaction(transaction_id)
+        @lock.synchronize do
+          @lock_graph.remove_transaction(transaction_id)
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            running: @running,
+            graph_size: @lock_graph.size,
+            graph_edges: @lock_graph.edge_count
+          })
+        end
+      end
+
+      private
+
+      def detection_loop
+        while @running
+          sleep(@timeout)
+          begin
+            detect_deadlocks
+          rescue
+            # Log error but continue
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/concurrency/latch.rb

@@ -1,101 +1,101 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Concurrency
-    # Latch - A synchronization primitive that allows threads to wait until a count reaches zero
-    class Latch
-      attr_reader :count, :stats
-
-      def initialize(count = 1)
-        @count = count
-        @mutex = Mutex.new
-        @cond = ConditionVariable.new
-        @stats = {
-          wait_count: 0,
-          signal_count: 0,
-          timed_out: 0
-        }
-      end
-
-      def await(timeout = nil)
-        @mutex.synchronize do
-          @stats[:wait_count] += 1
-
-          if timeout
-            deadline = Time.now + timeout
-            while @count > 0 && Time.now < deadline
-              @cond.wait(@mutex, [deadline - Time.now, 0.1].max)
-            end
-
-            if @count > 0
-              @stats[:timed_out] += 1
-              return false
-            end
-          else
-            while @count > 0
-              @cond.wait(@mutex)
-            end
-          end
-
-          true
-        end
-      end
-
-      def count_down(count = 1)
-        @mutex.synchronize do
-          @count -= count
-          @count = 0 if @count < 0
-          @stats[:signal_count] += count
-          @cond.broadcast if @count == 0
-        end
-      end
-
-      def count_up(count = 1)
-        @mutex.synchronize do
-          @count += count
-        end
-      end
-
-      def reset(count = nil)
-        @mutex.synchronize do
-          @count = count || @count
-          @cond.broadcast if @count == 0
-        end
-      end
-
-      def ready?
-        @mutex.synchronize { @count == 0 }
-      end
-
-      def wait(timeout = nil)
-        await(timeout)
-      end
-
-      def to_s
-        "Latch(count=#{@count})"
-      end
-
-      def inspect
-        to_s
-      end
-    end
-
-    # CountDownLatch - A latch that counts down from a specific number
-    class CountDownLatch < Latch
-      attr_reader :initial_count
-
-      def initialize(count)
-        super(count)
-        @initial_count = count
-      end
-
-      def reset
-        super(@initial_count)
-      end
-
-      def to_s
-        "CountDownLatch(count=#{@count}/#{@initial_count})"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Concurrency
+    # Latch - A synchronization primitive that allows threads to wait until a count reaches zero
+    class Latch
+      attr_reader :count, :stats
+
+      def initialize(count = 1)
+        @count = count
+        @mutex = Mutex.new
+        @cond = ConditionVariable.new
+        @stats = {
+          wait_count: 0,
+          signal_count: 0,
+          timed_out: 0
+        }
+      end
+
+      def await(timeout = nil)
+        @mutex.synchronize do
+          @stats[:wait_count] += 1
+
+          if timeout
+            deadline = Time.now + timeout
+            while @count > 0 && Time.now < deadline
+              @cond.wait(@mutex, [deadline - Time.now, 0.1].max)
+            end
+
+            if @count > 0
+              @stats[:timed_out] += 1
+              return false
+            end
+          else
+            while @count > 0
+              @cond.wait(@mutex)
+            end
+          end
+
+          true
+        end
+      end
+
+      def count_down(count = 1)
+        @mutex.synchronize do
+          @count -= count
+          @count = 0 if @count < 0
+          @stats[:signal_count] += count
+          @cond.broadcast if @count == 0
+        end
+      end
+
+      def count_up(count = 1)
+        @mutex.synchronize do
+          @count += count
+        end
+      end
+
+      def reset(count = nil)
+        @mutex.synchronize do
+          @count = count || @count
+          @cond.broadcast if @count == 0
+        end
+      end
+
+      def ready?
+        @mutex.synchronize { @count == 0 }
+      end
+
+      def wait(timeout = nil)
+        await(timeout)
+      end
+
+      def to_s
+        "Latch(count=#{@count})"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+
+    # CountDownLatch - A latch that counts down from a specific number
+    class CountDownLatch < Latch
+      attr_reader :initial_count
+
+      def initialize(count)
+        super
+        @initial_count = count
+      end
+
+      def reset
+        super(@initial_count)
+      end
+
+      def to_s
+        "CountDownLatch(count=#{@count}/#{@initial_count})"
+      end
+    end
+  end
+end