rubydb 0.1.0

data/lib/rubydb/concurrency/deadlock_detector.rb

@@ -0,0 +1,150 @@
+# 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

data/lib/rubydb/concurrency/latch.rb

@@ -0,0 +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

data/lib/rubydb/concurrency/lock_graph.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "set"
+
+module RubyDB
+  module Concurrency
+    # LockGraph - Represents the wait-for graph for deadlock detection
+    class LockGraph
+      attr_reader :nodes, :edges
+
+      def initialize
+        @nodes = {}  # transaction_id => {locks: [], waiting_for: []}
+        @edges = {}  # source => {target: edge_info}
+        @reverse_edges = {}  # target => [sources]
+        @lock = Mutex.new
+      end
+
+      def add_holder(resource, holder)
+        @lock.synchronize do
+          @nodes[holder[:id]] ||= {
+            id: holder[:id],
+            locks: [],
+            waiting_for: [],
+            info: holder
+          }
+          @nodes[holder[:id]][:locks] << resource
+        end
+      end
+
+      def add_waiter(resource, waiter)
+        @lock.synchronize do
+          @nodes[waiter[:id]] ||= {
+            id: waiter[:id],
+            locks: [],
+            waiting_for: [],
+            info: waiter
+          }
+          @nodes[waiter[:id]][:waiting_for] << resource
+
+          # Find who holds the resource
+          holders = find_holders(resource)
+          holders.each do |holder|
+            add_edge(waiter[:id], holder[:id], resource)
+          end
+        end
+      end
+
+      def remove_transaction(transaction_id)
+        @lock.synchronize do
+          # Remove all edges involving this transaction
+          @edges.delete(transaction_id)
+          @reverse_edges.delete(transaction_id)
+
+          @edges.each do |source, targets|
+            targets.delete(transaction_id)
+          end
+
+          @reverse_edges.each do |target, sources|
+            sources.delete(transaction_id)
+          end
+
+          @nodes.delete(transaction_id)
+        end
+      end
+
+      def release_locks(transaction_id)
+        @lock.synchronize do
+          node = @nodes[transaction_id]
+          return unless node
+
+          # Remove all resources locked by this transaction
+          node[:locks].clear
+          node[:waiting_for].clear
+
+          # Clean up edges
+          remove_transaction(transaction_id)
+        end
+      end
+
+      def build
+        @lock.synchronize do
+          # Rebuild graph from current state
+          # This would be called periodically
+          true
+        end
+      end
+
+      def detect_cycles
+        @lock.synchronize do
+          cycles = []
+          visited = Set.new
+          recursion_stack = Set.new
+
+          @nodes.each_key do |node|
+            if !visited.include?(node)
+              path = []
+              if detect_cycle_dfs(node, visited, recursion_stack, path)
+                cycles << path
+              end
+            end
+          end
+
+          cycles
+        end
+      end
+
+      def size
+        @nodes.size
+      end
+
+      def edge_count
+        @edges.values.sum(&:size)
+      end
+
+      def to_s
+        "LockGraph(nodes=#{@nodes.size}, edges=#{edge_count})"
+      end
+
+      private
+
+      def find_holders(resource)
+        holders = []
+        @nodes.each do |id, node|
+          if node[:locks].include?(resource)
+            holders << { id: id, info: node[:info] }
+          end
+        end
+        holders
+      end
+
+      def add_edge(source, target, resource)
+        @edges[source] ||= {}
+        @edges[source][target] = { resource: resource, timestamp: Time.now }
+
+        @reverse_edges[target] ||= Set.new
+        @reverse_edges[target] << source
+      end
+
+      def detect_cycle_dfs(node, visited, recursion_stack, path)
+        return false if visited.include?(node)
+
+        visited.add(node)
+        recursion_stack.add(node)
+        path << node
+
+        @edges[node]&.keys&.each do |neighbor|
+          if recursion_stack.include?(neighbor)
+            # Found a cycle
+            cycle_start = path.index(neighbor)
+            cycle = path[cycle_start..-1] + [neighbor]
+            return true
+          end
+
+          if detect_cycle_dfs(neighbor, visited, recursion_stack, path)
+            return true
+          end
+        end
+
+        recursion_stack.delete(node)
+        path.pop
+        false
+      end
+    end
+  end
+end

data/lib/rubydb/concurrency/mutex.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Concurrency
+    # Mutex - A mutual exclusion lock with additional features
+    class Mutex
+      attr_reader :name, :stats, :owner
+
+      def initialize(name = nil)
+        @mutex = ::Mutex.new
+        @name = name
+        @owner = nil
+        @lock_count = 0
+        @waiters = []
+        @stats = {
+          lock_attempts: 0,
+          lock_successes: 0,
+          lock_failures: 0,
+          unlock_count: 0,
+          contention_count: 0,
+          avg_wait_time_ms: 0,
+          total_wait_time_ms: 0
+        }
+        @lock = ::Mutex.new
+      end
+
+      def synchronize
+        lock
+        begin
+          yield
+        ensure
+          unlock
+        end
+      end
+
+      def lock(timeout = nil)
+        @lock.synchronize do
+          @stats[:lock_attempts] += 1
+
+          start_time = Time.now
+          current_thread = Thread.current
+
+          # If already locked by this thread, increment lock count
+          if @owner == current_thread
+            @lock_count += 1
+            @stats[:lock_successes] += 1
+            return true
+          end
+
+          # Try to acquire lock
+          success = if timeout
+            acquired = false
+            deadline = Time.now + timeout
+            while !acquired && Time.now < deadline
+              acquired = @mutex.try_lock
+              sleep(0.001) if !acquired
+            end
+            acquired
+          else
+            @mutex.lock
+            true
+          end
+
+          if success
+            @owner = current_thread
+            @lock_count = 1
+            @stats[:lock_successes] += 1
+
+            wait_time = (Time.now - start_time) * 1000
+            @stats[:total_wait_time_ms] += wait_time
+            @stats[:avg_wait_time_ms] = @stats[:total_wait_time_ms] / @stats[:lock_successes]
+          else
+            @stats[:lock_failures] += 1
+            false
+          end
+        end
+      end
+
+      def unlock
+        @lock.synchronize do
+          if @owner != Thread.current
+            raise ThreadError, "Mutex not owned by current thread"
+          end
+
+          @lock_count -= 1
+
+          if @lock_count == 0
+            @owner = nil
+            @mutex.unlock
+            @stats[:unlock_count] += 1
+          end
+
+          true
+        end
+      end
+
+      def locked?
+        @mutex.locked?
+      end
+
+      def try_lock
+        @lock.synchronize do
+          @stats[:lock_attempts] += 1
+
+          if @mutex.try_lock
+            @owner = Thread.current
+            @lock_count = 1
+            @stats[:lock_successes] += 1
+            true
+          else
+            @stats[:lock_failures] += 1
+            @stats[:contention_count] += 1
+            false
+          end
+        end
+      end
+
+      def owned?
+        @owner == Thread.current
+      end
+
+      def to_s
+        status = locked? ? "locked" : "unlocked"
+        "#{@name || 'Mutex'} (#{status}, owner=#{@owner&.object_id})"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+
+    # ReentrantMutex - A mutex that can be locked multiple times by the same thread
+    class ReentrantMutex < Mutex
+      def initialize(name = nil)
+        super(name)
+        @recursion_depth = 0
+      end
+
+      def lock(timeout = nil)
+        @lock.synchronize do
+          @stats[:lock_attempts] += 1
+
+          if @owner == Thread.current
+            @lock_count += 1
+            @recursion_depth += 1
+            @stats[:lock_successes] += 1
+            return true
+          end
+
+          super
+        end
+      end
+
+      def unlock
+        @lock.synchronize do
+          if @owner != Thread.current
+            raise ThreadError, "Mutex not owned by current thread"
+          end
+
+          @lock_count -= 1
+          @recursion_depth -= 1
+
+          if @lock_count == 0
+            @owner = nil
+            @mutex.unlock
+            @stats[:unlock_count] += 1
+          end
+
+          true
+        end
+      end
+
+      def recursion_depth
+        @recursion_depth
+      end
+
+      def to_s
+        status = locked? ? "locked" : "unlocked"
+        "#{@name || 'ReentrantMutex'} (#{status}, recursion=#{@recursion_depth})"
+      end
+    end
+  end
+end