rbsim 0.0.3

data/lib/rbsim/hlmodel.rb

@@ -0,0 +1,25 @@
+require 'rbsim/hlmodel/infrastructure.rb'
+require 'rbsim/hlmodel/process.rb'
+require 'rbsim/hlmodel/mapping.rb'
+
+module RBSim
+  module HLModel
+
+    Model = Struct.new :nodes, :nets, :routes, :programs, :processes, :mapping, :simulator do
+      def initialize(*)
+        super
+        self.programs = {}
+        self.processes = {}
+        self.mapping = Mapping.new
+        self.routes = Tokens::RoutesToken.new
+        self.each_pair do |attr, val|
+          if val.nil?
+            self.send "#{attr}=".to_sym, []
+          end
+        end
+        self.simulator = nil
+      end
+    end
+
+  end
+end

data/lib/rbsim/hlmodel/infrastructure.rb

@@ -0,0 +1,116 @@
+module RBSim
+  module HLModel
+
+    Node = Struct.new :name, :cpus
+    class Node
+      CPU = Struct.new :performance, :node, :tags
+    end
+
+    class Net
+      attr_reader :name, :bw, :delay, :drop, :tags
+
+      InvalidTypeOfDropParameter = Class.new RuntimeError
+      InvalidValueOfDropProbability = Class.new RuntimeError
+
+      def initialize(name, bw, delay = 0, drop = 0, tags = {})
+        @name, @bw, @delay = name, bw, delay
+        @drop = drop
+        @tags = tags
+        unless @drop.kind_of?(Proc) || @drop.kind_of?(Numeric)
+          raise InvalidTypeOfDropParameter.new(@drop.class)
+        end
+        if @drop.kind_of? Numeric
+          if @drop > 1 || @drop < 0
+            raise InvalidValueOfDropProbability.new(@drop)
+          end
+        end
+        @drop_next = drop_next?
+      end
+
+      def drop?
+        drop_this = @drop_next
+        @drop_next = drop_next?
+        drop_this
+      end
+
+      private
+
+      def drop_next?
+        return @drop.call if @drop.kind_of? Proc
+
+        # a little optimization ;-)
+        return true if @drop == 1
+        return false if @drop == 0
+
+        return rand <= @drop
+      end
+    end
+
+    class Routes
+      def initialize
+        @routes = {}
+      end
+
+      def add(route)
+        key = [route.src, route.dst]
+        @routes[key] ||= []
+        @routes[key] << route
+        if route.twoway?
+          @routes[key.reverse] ||= []
+          @routes[key.reverse] << route
+        end
+      end
+      alias << add
+
+      def find(src, dst)
+        routes = @routes[[src, dst]]
+        return nil if routes.nil?
+        route = if routes.size == 1
+                  routes.first
+                else
+                  routes[rand(routes.size)]
+                end
+        if route.src == src
+          route
+        else
+          route.reverse!
+        end
+      end
+
+    end
+
+    Route = Struct.new :src, :dst, :via, :twoway do
+
+      CannotReverseOnewayRoute = Class.new RuntimeError
+
+      def initialize(*)
+        super
+        self.twoway = false unless self.twoway
+        @net_number = 0
+      end
+
+      def next_net
+        raise StopIteration if @net_number >= via.length
+        net = via[@net_number]
+        @net_number += 1
+        net
+      end
+
+      def has_next_net?
+        @net_number < via.length
+      end
+
+      def reverse!
+        raise CannotReverseOnewayRoute unless self.twoway
+        self.via = self.via.reverse
+        self.src, self.dst = self.dst, self.src
+        @net_enum = nil
+        self
+      end
+
+      def twoway?
+        twoway
+      end
+    end
+  end
+end

data/lib/rbsim/hlmodel/mapping.rb

@@ -0,0 +1,5 @@
+module RBSim
+  module HLModel
+    Mapping = Class.new Hash
+  end
+end

data/lib/rbsim/hlmodel/process.rb

@@ -0,0 +1,152 @@
+module RBSim
+  module HLModel
+
+    class Process
+      NoHandlerForUserEvent = Class.new RuntimeError
+      InvalidEventType = Class.new RuntimeError
+      InvalidSystemEventPassed = Class.new RuntimeError
+      NoEventToServe = Class.new RuntimeError
+      NotAssignedToNode = Class.new RuntimeError
+
+      attr_reader :name, :program, :functions, :tags
+      attr_accessor :node
+      # to how many fragments should be
+      # divided data sent by this process?
+      attr_accessor :data_fragmentation
+
+      alias id name
+
+      # +name+: name of this process used to assign it to a node
+      # +program+: name of program running in this process (if any name was given); this is just for information
+      def initialize(name, program = nil, tags = {})
+        @event_handlers = { data_received: generic_data_received_handler }
+        @event_queue = []
+        @name = name
+        @program = program
+        @tags = tags || {}
+        @functions = {}
+        @data_fragmentation = 1
+      end
+
+      # define a new reusable function for this program
+      def function(name, &block)
+        @functions[name] = block
+      end
+
+      # define event handler
+      def on_event(event, &block)
+        @event_handlers[event] = block
+      end
+
+      # event just happened
+      def enqueue_event(event, args = nil)
+        handler = nil # system event has no handling code defined here
+                      # it must be handled by somethig external, like
+                      # TCPN transition!
+        unless system_event_names.include? event
+          handler = @event_handlers[event]
+          if handler.nil?
+            raise NoHandlerForUserEvent.new(event)
+          end
+        end
+        @event_queue << { name: event, block: handler, args: args }
+      end
+
+      # serve first event if it is a user event
+      def serve_user_event
+        check_if_assigned!
+        if has_system_event?
+          raise InvalidEventType.new("#{@event_queue.first[:name]} is not a user event!")
+        end
+        event = @event_queue.shift
+        event[:block].call self, event[:args]
+      end
+
+      # serve first event if it is a system event
+      def serve_system_event(name)
+        check_if_assigned!
+        unless has_event?
+          raise NoEventToServe.new
+        end
+        unless has_event? name
+          raise InvalidSystemEventPassed.new("You tried to serve: #{name}, but first in queue is: #{@event_queue.first[:name]}")
+        end
+        if has_user_event?
+          raise InvalidEventType.new("#{@event_queue.first[:name]} is not a system event!")
+        end
+        event = @event_queue.shift
+        { name: event[:name], args: event[:args] }
+      end
+
+      # is there a user event to serve?
+      def has_user_event?
+        return false unless has_event?
+        return false if system_event_names.include? @event_queue.first[:name]
+        true
+      end
+
+      # is there a system event to serve?
+      def has_system_event?
+        return false unless has_event?
+        return true if system_event_names.include? @event_queue.first[:name]
+        false
+      end
+
+      # is there any event to serve?
+      def has_event?(name = nil)
+        return false if @event_queue.empty?
+        return true if name == nil
+        return true if @event_queue.first[:name] == name
+        false
+      end
+
+      # returns name of the first event in queue
+      def first_event
+        event = @event_queue.first
+        if event.nil?
+          nil
+        else
+          event[:name]
+        end
+      end
+
+      def handlers_size
+        @event_handlers.size
+      end
+
+      def event_queue_size
+        @event_queue.size
+      end
+
+      # system events need special handling, by special
+      # transitions, e.g. :cpu event requires a cpu token
+      # :delay_for requires change in timestamp, etc.
+      # handlers for system events must be implemented
+      # in simulator!
+      def system_event_names
+        [ :cpu,  :delay_for, :send_data, :new_process, :register_event, :log, :stats_start, :stats_stop, :stats, :stats_save ]
+      end
+
+      # Start new process on the same node
+      # used when creating new process during simulation
+      def new(program = nil)
+        self.class.new @node, program
+      end
+
+      private
+      def check_if_assigned!
+        if @node.nil?
+          raise NotAssignedToNode.new("process #{@name} will not serve events until assigned to a node!")
+        end
+      end
+
+      def generic_data_received_handler
+        proc do |process, data|
+          STDERR.puts "WARNING! Process #{process.name} on node #{process.node} received data, but has no handler defined! Define handler for event :data_received! Data packege will be dropped! Received data: #{data}"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/rbsim/numeric_units.rb

@@ -0,0 +1,107 @@
+#
+# This file extends Ruby Numeric class by methods
+# used in RBSim to desciribe units of time,
+# data volume and network speed.
+#
+# Native data volume unit is one bit
+# Native network speed unit is one bit per second
+# Time unit is one jiffie, defined by Numric::RBSIM_JIFFIES_PER_SECOND
+class Numeric
+
+  #
+  # Time units
+  #
+
+
+  # Defines unit of time -- jiffie is the smallest
+  # time unit that can be accounted by simulator
+  RBSIM_JIFFIES_PER_SECOND = 1000000
+
+  def seconds
+    self * RBSIM_JIFFIES_PER_SECOND
+  end
+
+  def miliseconds
+    self.seconds / 1000
+  end
+
+  def microseconds
+    self.miliseconds / 1000
+  end
+
+  def minutes
+    self.seconds * 60
+  end
+
+  def hours
+    self.minutes * 60
+  end
+
+  def days
+    self.hours * 24
+  end
+
+  def in_seconds
+    self / RBSIM_JIFFIES_PER_SECOND
+  end
+
+  def in_miliseconds
+    self * 1000 / RBSIM_JIFFIES_PER_SECOND
+  end
+
+  def in_microseconds
+    self * 1000 * 1000 / RBSIM_JIFFIES_PER_SECOND
+  end
+
+  def in_minutes
+    self.in_seconds / 60
+  end
+
+  def in_hours
+    self.in_minutes / 60
+  end
+
+  def in_days
+    self.in_hours / 24
+  end
+
+  #
+  # Data volume units
+  #
+
+  def bytes
+    self * 8
+  end
+
+  def in_bytes
+    self / 8
+  end
+
+  def in_bits
+    self
+  end
+
+  def bits
+    self
+  end
+
+  #
+  # Network throuput units
+  #
+
+  def bps
+    self.to_f.in_seconds
+  end
+
+  def Bps
+    (self * 8).to_f.in_seconds
+  end
+
+  def in_bps
+    self.seconds
+  end
+
+  def in_Bps
+    (self / 8).seconds
+  end
+end

data/lib/rbsim/simulator.rb

@@ -0,0 +1,184 @@
+module RBSim
+
+  class Simulator
+    attr_reader :clock
+    # To how many fragments should be divided data
+    # sent over the network?
+    attr_accessor :data_fragmentation
+
+    # Create new simulator
+    # +block+ defines new model
+    # +params+ will be passed as block parameter to the model
+    def initialize(params = {}, &block)
+      @block = block
+      @params = params
+      @logger = default_logger
+      @stats_collector = Statistics.new
+      @resource_stats_collector = Statistics.new
+      @clock = 0
+      @data_fragmentation = 1
+    end
+
+    def data_fragmentation=(d)
+      raise "TCPN already initialized. Too late to set data fragmentation" unless @tcpn.nil?
+      @data_fragmentation = d
+    end
+
+    def run
+      simulator.run
+    end
+
+    def stop
+      simulator.stop
+    end
+
+    def hlmodel
+      if @hlmodel.nil?
+        @hlmodel = RBSim::HLModel::Model.new
+        @hlmodel.simulator = self
+        Docile.dsl_eval(RBSim::DSL.new(@hlmodel), @params, &@block)
+      end
+      @hlmodel
+    end
+
+    def tcpn
+      if @tcpn.nil?
+        @tcpn = FastTCPN.read File.expand_path '../../../tcpn/model.rb', __FILE__
+        hlmodel.nets.each do |net|
+          @tcpn.add_marking_for 'net', net
+        end
+
+        hlmodel.nodes.each do |node|
+          node.cpus.each do |cpu|
+            cpu.node = node.name
+            @tcpn.add_marking_for 'CPU', cpu
+          end
+        end
+
+        hlmodel.processes.each do |name, process|
+          process.node = hlmodel.mapping[name]
+          process.data_fragmentation = data_fragmentation
+          @tcpn.add_marking_for 'process', process
+          @tcpn.add_marking_for 'data to receive', Tokens::DataQueueToken.new(process.name, process.tags)
+        end
+
+
+        @tcpn.add_marking_for 'routes', hlmodel.routes
+        @tcpn.add_marking_for 'mapping', hlmodel.mapping
+
+
+      end
+
+      @tcpn
+    end
+
+    def simulator
+      if @simulator.nil?
+        @simulator = tcpn
+
+        set_logger_callbacks
+        set_stats_collector_callbacks
+        set_clock_callbacks
+
+      end
+      @simulator
+    end
+
+    def logger(&block)
+      @logger = block
+    end
+
+    def stats
+      { application: @stats_collector, resources: @resource_stats_collector }
+    end
+
+    # FIXME: not tested!
+    def stats_save(file)
+      File.open file, 'w' do |f|
+        f.puts Marshal.dump(stats_data)
+      end
+    end
+
+    private
+
+    def default_logger
+      proc do |clock, message|
+        puts "%.3f: #{message}" % (clock.to_f.in_seconds)
+      end
+    end
+
+    def set_logger_callbacks
+      @simulator.cb_for :transition, :after do |t, e|
+        if e.transition == 'event::log'
+          message = e.binding['process'].value.serve_system_event(:log)[:args]
+          @logger.call e.clock, message
+        end
+      end
+    end
+
+    def set_stats_collector_callbacks
+      @simulator.cb_for :transition, :after do |t, e|
+        if e.transition == "event::stats"
+          process = e.binding['process'].value
+          event = process.first_event
+          params = process.serve_system_event(event)[:args]
+          @stats_collector.event event.to_s.sub(/^stats_/,'').to_sym, params, e.clock
+        elsif e.transition == "event::cpu"
+          cpu = e.binding['CPU'].value
+          @resource_stats_collector.event :start, cpu.tags.merge({ resource: 'CPU', node: cpu.node }), e.clock
+        elsif e.transition == "event::cpu_finished"
+          cpu = e.binding['working CPU'].value[:cpu]
+          @resource_stats_collector.event :stop, cpu.tags.merge({ resource: 'CPU', node: cpu.node }), e.clock
+        elsif e.transition == "transmitted"
+          process = e.binding['data after net'].value.dst
+          queue = e.binding['data to receive'].value
+          @resource_stats_collector.event :start, queue.process_tags.merge({ resource: 'DATAQ WAIT', process: process }), e.clock
+        elsif e.transition == "event::data_received"
+          process = e.binding['process'].value
+          @resource_stats_collector.event :stop, process.tags.merge({ resource: 'DATAQ WAIT', process: process.name }), e.clock
+        elsif e.transition == "net"
+          net = e.binding['net'].value
+          dropped = e.binding['net'].value.drop?
+          if dropped
+            @resource_stats_collector.event :stats, net.tags.merge({ event: 'NET DROP', net: net.name }), e.clock
+          end
+        end
+      end
+
+      @simulator.cb_for :place, :remove do |t, e|
+        if e.place == 'net'
+          net = e.tokens.first.value
+          @resource_stats_collector.event :start, net.tags.merge({ resource: 'NET', name: net.name }), e.clock
+        end
+      end
+      @simulator.cb_for :place, :add do |t, e|
+        if e.place == 'net'
+          net = e.tokens.first[:val]
+          ts = e.tokens.first[:ts]
+          @resource_stats_collector.event :stop, net.tags.merge({ resource: 'NET', name: net.name }), ts
+        elsif e.place == 'data to receive'
+          queue = e.tokens.first[:val]
+          process_name = queue.process_name
+          process_tags = queue.process_tags
+          @resource_stats_collector.event :save,
+            { value: queue.length, tags: process_tags.merge({ resource: 'DATAQ LEN', process: process_name }) },
+            e.tcpn.clock
+        end
+      end
+    end
+
+    def set_clock_callbacks
+      @simulator.cb_for :clock, :after do |t, e|
+        self.clock = e.clock
+      end
+    end
+
+    def clock=(clock)
+      @clock = clock
+      @stats_collector.clock = clock
+      @resource_stats_collector.clock = clock
+    end
+
+  end
+
+end