rubydb 0.1.0

data/lib/rubydb/concurrency/rw_lock.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Concurrency
+    # RWLock - Read-Write lock with fairness
+    class RWLock
+      attr_reader :stats
+
+      def initialize(config = {})
+        @mutex = Mutex.new
+        @readers = 0
+        @writers = 0
+        @pending_readers = 0
+        @pending_writers = 0
+        @prefer_writer = config[:prefer_writer] || false
+        @fair = config[:fair] || true
+        @stats = {
+          read_locks: 0,
+          write_locks: 0,
+          read_unlocks: 0,
+          write_unlocks: 0,
+          read_waits: 0,
+          write_waits: 0,
+          contention: 0
+        }
+        @cond = ConditionVariable.new
+        @lock = Mutex.new
+      end
+
+      def read_lock(timeout = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:read_locks] += 1
+
+          # Wait if there are writers or pending writers
+          while (@writers > 0 || (@prefer_writer && @pending_writers > 0)) ||
+                (@fair && @pending_writers > 0 && @pending_readers > @pending_writers)
+            @stats[:read_waits] += 1
+            @stats[:contention] += 1
+            
+            if timeout
+              deadline = Time.now + timeout
+              @cond.wait(@lock, [deadline - Time.now, 0.1].max)
+              if Time.now >= deadline && (@writers > 0 || @pending_writers > 0)
+                return false
+              end
+            else
+              @cond.wait(@lock)
+            end
+          end
+
+          @readers += 1
+          @stats[:read_waits] += 1 if Time.now - start_time > 0.01
+          true
+        end
+      end
+
+      def write_lock(timeout = nil)
+        @lock.synchronize do
+          start_time = Time.now
+          @stats[:write_locks] += 1
+          @pending_writers += 1
+
+          # Wait until no readers or writers
+          while @readers > 0 || @writers > 0 || @pending_readers > 0
+            @stats[:write_waits] += 1
+            @stats[:contention] += 1
+
+            if timeout
+              deadline = Time.now + timeout
+              @cond.wait(@lock, [deadline - Time.now, 0.1].max)
+              if Time.now >= deadline && (@readers > 0 || @writers > 0)
+                @pending_writers -= 1
+                return false
+              end
+            else
+              @cond.wait(@lock)
+            end
+          end
+
+          @pending_writers -= 1
+          @writers += 1
+          true
+        end
+      end
+
+      def read_unlock
+        @lock.synchronize do
+          if @readers <= 0
+            raise "No readers to unlock"
+          end
+
+          @readers -= 1
+          @stats[:read_unlocks] += 1
+          @cond.broadcast if @readers == 0
+          true
+        end
+      end
+
+      def write_unlock
+        @lock.synchronize do
+          if @writers <= 0
+            raise "No writers to unlock"
+          end
+
+          @writers -= 1
+          @stats[:write_unlocks] += 1
+          @cond.broadcast
+          true
+        end
+      end
+
+      def with_read_lock
+        if read_lock
+          begin
+            yield
+          ensure
+            read_unlock
+          end
+        end
+      end
+
+      def with_write_lock
+        if write_lock
+          begin
+            yield
+          ensure
+            write_unlock
+          end
+        end
+      end
+
+      def try_read_lock
+        @lock.synchronize do
+          if @writers == 0 && !(@prefer_writer && @pending_writers > 0)
+            @readers += 1
+            @stats[:read_locks] += 1
+            true
+          else
+            @stats[:contention] += 1
+            false
+          end
+        end
+      end
+
+      def try_write_lock
+        @lock.synchronize do
+          if @readers == 0 && @writers == 0
+            @writers += 1
+            @stats[:write_locks] += 1
+            true
+          else
+            @stats[:contention] += 1
+            false
+          end
+        end
+      end
+
+      def reader_count
+        @readers
+      end
+
+      def writer_count
+        @writers
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            readers: @readers,
+            writers: @writers,
+            pending_readers: @pending_readers,
+            pending_writers: @pending_writers,
+            total_locks: @stats[:read_locks] + @stats[:write_locks]
+          })
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/concurrency/scheduler.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "thread"
+require "set"
+require "time"
+
+module RubyDB
+  module Concurrency
+    # Scheduler - Manages execution of concurrent tasks with priorities
+    class Scheduler
+      attr_reader :stats, :queue_size
+
+      # Scheduling policies
+      POLICY_FIFO = :fifo
+      POLICY_PRIORITY = :priority
+      POLICY_ROUND_ROBIN = :round_robin
+      POLICY_FAIR = :fair
+
+      def initialize(config = {})
+        @policy = config[:policy] || POLICY_FIFO
+        @max_threads = config[:max_threads] || (Etc.nprocessors * 2)
+        @min_threads = config[:min_threads] || [2, Etc.nprocessors].min
+        @queue_size = 0
+        @thread_pool = []
+        @task_queue = []
+        @priority_queues = {}
+        @stats = {
+          tasks_submitted: 0,
+          tasks_completed: 0,
+          tasks_failed: 0,
+          tasks_queued: 0,
+          avg_wait_time_ms: 0,
+          avg_execution_time_ms: 0,
+          total_wait_time_ms: 0,
+          total_execution_time_ms: 0
+        }
+        @lock = Mutex.new
+        @cond = ConditionVariable.new
+        @running = false
+        @shutdown = false
+        @scheduler_thread = nil
+
+        # Initialize priority queues
+        [1, 2, 3, 4, 5].each do |priority|
+          @priority_queues[priority] = []
+        end
+
+        start
+      end
+
+      def start
+        @lock.synchronize do
+          return if @running
+
+          @running = true
+          @shutdown = false
+
+          # Start worker threads
+          @min_threads.times do
+            start_worker
+          end
+
+          # Start scheduler thread
+          @scheduler_thread = Thread.new do
+            schedule_loop
+          end
+        end
+      end
+
+      def stop(wait = true)
+        @lock.synchronize do
+          @shutdown = true
+          @cond.broadcast
+
+          if wait
+            @scheduler_thread&.join
+            @thread_pool.each(&:join)
+          end
+        end
+      end
+
+      def submit(task, priority: 3, timeout: nil)
+        @lock.synchronize do
+          raise "Scheduler is shutting down" if @shutdown
+
+          entry = {
+            task: task,
+            priority: priority,
+            submitted_at: Time.now,
+            timeout: timeout,
+            status: :queued
+          }
+
+          if priority.is_a?(Integer) && priority.between?(1, 5)
+            @priority_queues[priority] << entry
+          else
+            @task_queue << entry
+          end
+
+          @queue_size += 1
+          @stats[:tasks_submitted] += 1
+          @stats[:tasks_queued] += 1
+          @cond.signal
+
+          entry
+        end
+      end
+
+      def submit_block(priority: 3, timeout: nil, &block)
+        submit(block, priority: priority, timeout: timeout)
+      end
+
+      def wait_for_task(task_entry, timeout: nil)
+        start_time = Time.now
+        deadline = timeout ? start_time + timeout : nil
+
+        loop do
+          @lock.synchronize do
+            break if task_entry[:status] == :completed || task_entry[:status] == :failed
+
+            if deadline && Time.now > deadline
+              task_entry[:status] = :timeout
+              break
+            end
+
+            @cond.wait(@lock, 0.1)
+          end
+        end
+
+        task_entry[:result]
+      end
+
+      def running?
+        @running
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            queue_size: @queue_size,
+            threads: @thread_pool.size,
+            running: @running,
+            policy: @policy,
+            max_threads: @max_threads,
+            min_threads: @min_threads
+          })
+        end
+      end
+
+      private
+
+      def start_worker
+        worker = Thread.new do
+          worker_loop
+        end
+        @thread_pool << worker
+        worker
+      end
+
+      def worker_loop
+        while !@shutdown
+          task_entry = nil
+
+          @lock.synchronize do
+            while !@shutdown && !has_task?
+              @cond.wait(@lock, 1)
+            end
+
+            task_entry = dequeue_task
+          end
+
+          if task_entry
+            execute_task(task_entry)
+          end
+        end
+      end
+
+      def schedule_loop
+        while !@shutdown
+          sleep(1) if @thread_pool.size >= @max_threads
+
+          @lock.synchronize do
+            # Adjust thread pool size based on workload
+            if @queue_size > @thread_pool.size * 2 && @thread_pool.size < @max_threads
+              start_worker
+            elsif @queue_size < @thread_pool.size / 2 && @thread_pool.size > @min_threads
+              # Could shrink pool
+            end
+          end
+        end
+      end
+
+      def has_task?
+        @task_queue.any? || @priority_queues.any? { |_, q| q.any? }
+      end
+
+      def dequeue_task
+        # Priority-based dequeuing
+        @priority_queues.keys.sort.each do |priority|
+          queue = @priority_queues[priority]
+          if queue.any?
+            entry = queue.shift
+            @queue_size -= 1
+            return entry
+          end
+        end
+
+        if @task_queue.any?
+          entry = case @policy
+          when POLICY_FIFO
+            @task_queue.shift
+          when POLICY_ROUND_ROBIN
+            @task_queue.rotate!.first
+          else
+            @task_queue.shift
+          end
+          @queue_size -= 1
+          return entry
+        end
+
+        nil
+      end
+
+      def execute_task(task_entry)
+        start_time = Time.now
+        task_entry[:status] = :running
+
+        begin
+          result = if task_entry[:task].is_a?(Proc)
+            task_entry[:task].call
+          else
+            task_entry[:task]
+          end
+
+          task_entry[:status] = :completed
+          task_entry[:result] = result
+          @stats[:tasks_completed] += 1
+        rescue => e
+          task_entry[:status] = :failed
+          task_entry[:error] = e
+          @stats[:tasks_failed] += 1
+        ensure
+          execution_time = (Time.now - start_time) * 1000
+          @stats[:total_execution_time_ms] += execution_time
+          @stats[:avg_execution_time_ms] = @stats[:total_execution_time_ms] / @stats[:tasks_completed] if @stats[:tasks_completed] > 0
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/concurrency/worker_pool.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RubyDB
+  module Concurrency
+    # WorkerPool - Manages a pool of worker threads
+    class WorkerPool
+      attr_reader :stats, :size, :active_count, :idle_count
+
+      def initialize(config = {})
+        @size = config[:size] || Etc.nprocessors
+        @max_size = config[:max_size] || @size * 2
+        @min_size = config[:min_size] || [1, @size].min
+        @workers = []
+        @task_queue = Queue.new
+        @stats = {
+          tasks_processed: 0,
+          tasks_failed: 0,
+          tasks_queued: 0,
+          avg_processing_time_ms: 0,
+          total_processing_time_ms: 0,
+          worker_creations: 0,
+          worker_destructions: 0
+        }
+        @shutdown = false
+        @lock = Mutex.new
+        @cond = ConditionVariable.new
+        @idle_count = 0
+        @active_count = 0
+        @worker_id_counter = 0
+
+        # Pre-create workers
+        @size.times { create_worker }
+      end
+
+      def submit(task)
+        @task_queue << task
+        @stats[:tasks_queued] += 1
+        @cond.signal
+        task
+      end
+
+      def submit_block(&block)
+        submit(block)
+      end
+
+      def shutdown(wait = true)
+        @lock.synchronize do
+          @shutdown = true
+          @cond.broadcast
+
+          if wait
+            @workers.each(&:join)
+          end
+        end
+      end
+
+      def resize(new_size)
+        @lock.synchronize do
+          new_size = [new_size, @min_size].max
+          new_size = [new_size, @max_size].min
+
+          if new_size > @workers.size
+            (new_size - @workers.size).times { create_worker }
+          elsif new_size < @workers.size
+            (new_size - @workers.size).times do
+              worker = @workers.pop
+              worker&.kill
+              @stats[:worker_destructions] += 1
+            end
+          end
+
+          @size = new_size
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            size: @size,
+            workers: @workers.size,
+            active: @active_count,
+            idle: @idle_count,
+            queue_size: @task_queue.size,
+            max_size: @max_size,
+            min_size: @min_size,
+            shutdown: @shutdown
+          })
+        end
+      end
+
+      private
+
+      def create_worker
+        @worker_id_counter += 1
+        worker_id = @worker_id_counter
+
+        worker = Thread.new do
+          worker_loop(worker_id)
+        end
+
+        @workers << worker
+        @stats[:worker_creations] += 1
+        worker
+      end
+
+      def worker_loop(worker_id)
+        while !@shutdown
+          task = nil
+
+          begin
+            task = @task_queue.pop
+            @lock.synchronize { @idle_count -= 1; @active_count += 1 }
+
+            start_time = Time.now
+
+            if task.is_a?(Proc)
+              task.call
+            elsif task.respond_to?(:call)
+              task.call
+            end
+
+            processing_time = (Time.now - start_time) * 1000
+            @lock.synchronize do
+              @stats[:tasks_processed] += 1
+              @stats[:total_processing_time_ms] += processing_time
+              @stats[:avg_processing_time_ms] = @stats[:total_processing_time_ms] / @stats[:tasks_processed]
+            end
+
+          rescue => e
+            @lock.synchronize do
+              @stats[:tasks_failed] += 1
+            end
+          ensure
+            @lock.synchronize do
+              @active_count -= 1
+              @idle_count += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end