rbsim 0.0.3

data/TODO

@@ -0,0 +1,28 @@
+ * Error handling:
+ ** when there is not route between two processes, packets sent
+    between them are silently ignored -- no error message
+
+ * Add to README.md description of preferred RBSim usage scenario describing
+   usage of RBSim::Experiment. Good usage example can be found in
+   nauka/mrzasa_dynosize/
+ * Maybe it would be useful to add optional `:preemption` parameter to `cpu`
+   statement in process model to enable user to define preemption levels.
+   Currently, it can be done with the following piece of code:
+
+             10.times do # can be preempted 10 times
+               cpu do |cpu|
+                 cpu_time / 10 / cpu.performance
+               end
+             end
+
+   Obviously, it slows down simulation and makes stats swell (every cpu event
+   is logged in stats), but sometimes may be required.  The preemption
+   parameter could itself do the above.
+
+ * Data to self imlementation will spoil DATAQ WAIT stats -- no
+   stats_start is called when network is passed over! Neet to add
+   stats_start
+ * To speed-up simulation, we may create a token with one data queue
+   for each net segment in place 'data with route', if multiple data
+   packages are send in one moment, simulator will not choke on large
+   cartesian product in transition 'net'

data/basic_sim.rb

@@ -0,0 +1,62 @@
+require 'rbsim'
+
+model = RBSim.model do
+
+  program :wget do |opts|
+    sent = 0
+    on_event :send do
+      cpu do |cpu|
+        (150 / cpu.performance).miliseconds
+      end
+      send_data to: opts[:target], size: 1024.bytes, type: :request, content: sent
+      sent += 1
+      register_event :send, delay: 5.miliseconds if sent < opts[:count]
+    end
+
+    on_event :data_received do |data|
+      log "Got data #{data} in process #{process.name}"
+      stats :request_served, process.name
+    end
+
+    register_event :send
+  end
+
+  program :apache do
+    on_event :data_received do |data|
+      stats_start :apache, process.name
+      cpu do |cpu|
+        (100 * data.size.in_bytes / cpu.performance).miliseconds
+      end
+      send_data to: data.src, size: data.size * 10, type: :response, content: data.content
+      stats_stop :apache, process.name
+    end
+  end
+
+  node :desktop do
+    cpu 100
+  end
+
+  node :gandalf do
+    cpu 1400
+  end
+
+  new_process :client1, program: :wget, args: { target: :server, count: 10 }
+  new_process :client2, program: :wget, args: { target: :server, count: 10 }
+  new_process :server, program: :apache, args: 'apache1'
+
+  net :net01, bw: 1024.bps
+  net :net02, bw: 510.bps
+
+  route from: :desktop, to: :gandalf, via: [ :net01, :net02 ], twoway: true
+
+  put :server, on: :gandalf
+  put :client1, on: :desktop
+  put :client2, on: :desktop
+
+end
+
+
+model.run
+
+model.stats_print
+p model.stats_summary

data/fast-tcpn.rb

@@ -0,0 +1,3 @@
+require 'fast-tcpn'
+
+FastTCPN.read 'tcpn/model.rb'

data/lib/rbsim.rb

@@ -0,0 +1,14 @@
+require 'fast-tcpn'
+require 'rbsim/dsl'
+require 'rbsim/hlmodel'
+require 'rbsim/simulator'
+require 'rbsim/statistics'
+require 'rbsim/numeric_units'
+require 'rbsim/experiment'
+require 'rbsim/version'
+
+module RBSim
+  def self.stats_read(file)
+    Marshal.load File.read(file)
+  end
+end

data/lib/rbsim/dsl.rb

@@ -0,0 +1,30 @@
+require 'docile'
+require 'rbsim/tokens'
+require 'rbsim/dsl/infrastructure'
+require 'rbsim/dsl/program'
+require 'rbsim/dsl/process'
+require 'rbsim/dsl/mapping'
+
+module RBSim
+
+  def self.dsl(&block)
+    hlmodel = RBSim::HLModel::Model.new
+    Docile.dsl_eval(RBSim::DSL.new(hlmodel), &block)
+    hlmodel
+  end
+
+  # TODO: after implementing marking TCPN from the HLModel, update spec/integration/new_process_spec.rb!
+
+  def self.model(params = {}, &block)
+    Simulator.new params, &block
+  end
+
+  # Read model from a +file+.
+  # +params+ will be passes as to the model as 'params' variable
+  def self.read(file, params = {})
+    p = "proc { |params| #{File.read file} }"
+    block = instance_eval p, file
+    model params, &block
+  end
+
+end

data/lib/rbsim/dsl/infrastructure.rb

@@ -0,0 +1,48 @@
+module RBSim
+  class DSL
+    def initialize(model)
+      @model = model
+    end
+
+    def node(name, &block)
+      @model.nodes << Docile.dsl_eval(NodeDSL.new(name), &block).build
+    rescue => e
+      puts e
+      raise
+    end
+
+    def net(name, args = {})
+      bw = args[:bw]
+      delay = args[:delay] || 0
+      drop = args[:drop] || 0
+      tags = args[:tags] || {}
+      @model.nets << Tokens::NetToken.new(name, bw, delay, drop, tags)
+    end
+
+    def route(args = {})
+      twoway = if args[:twoway] || args[:twoway] == :true
+                 true
+               else
+                 false
+               end
+      @model.routes << HLModel::Route.new(args[:from], args[:to], args[:via], twoway)
+    end
+  end
+
+  class NodeDSL
+    def initialize(name)
+      @name = name
+      @cpus = []
+    end
+
+    def cpu(performance, args = {})
+      tags = args[:tags] || {}
+      @cpus << Tokens::CPUToken.new(performance, nil, tags)
+    end
+
+    def build
+      HLModel::Node.new(@name, @cpus)
+    end
+
+  end
+end

data/lib/rbsim/dsl/mapping.rb

@@ -0,0 +1,32 @@
+module RBSim
+  class DSL
+    IncorrectMapping = Class.new RuntimeError
+
+    def put(process_name, opts = nil)
+      if !process_name.instance_of?(Hash) && opts.nil?
+        raise IncorrectMapping.new("Does not define node for proces #{process_name}")
+      end
+
+      if process_name.instance_of? Hash
+        opts = process_name
+      else
+        opts[:process] = process_name
+      end
+
+      process = opts[:process]
+      node = opts[:on]
+
+      if process.nil?
+        msg = " to put on node #{node}" unless node.nil?
+        raise IncorrectMapping.new("Does not define process#{msg}")
+      end
+      if node.nil?
+        raise IncorrectMapping.new("Does not define node for proces #{process}")
+      end
+
+      @model.mapping[process] = node
+
+    end
+  end
+end
+

data/lib/rbsim/dsl/process.rb

@@ -0,0 +1,129 @@
+module RBSim
+  class DSL
+    def new_process(name, opts = {}, &block)
+      ProcessDSL.new_process(@model, name, opts, &block)
+    end
+  end
+
+  class ProcessDSL
+    UnknownProgramName = Class.new RuntimeError
+    NeitherBlockNorProgramGiven = Class.new RuntimeError
+
+    attr_reader :process
+
+    # Create new process.
+    # +name+ process name
+    # +opts+ +{ program: name_of_program_to_run, args: args_to_pass_to_program_block }+
+    # +block+ block defining new process (if given +opts+ are ignored)
+    def self.new_process(model, name, opts = {}, &block)
+      args = nil
+      program = nil
+      unless block_given?
+        program = opts[:program]
+        raise NeitherBlockNorProgamGiven.new("for new_process #{name}") if program.nil?
+        args = opts[:args]
+        block = model.programs[program]
+        raise UnknownProgramName.new("#{program} for new_process #{name}") if block.nil?
+      end
+      process = Tokens::ProcessToken.new(name, program, opts[:tags])
+      process = Docile.dsl_eval(ProcessDSL.new(model, name, program, process), args, &block).process
+      model.processes[name] = process
+    end
+
+    def initialize(model, name, program, process)
+      @name = name
+      @model = model
+      @program = program
+      @process = process
+    end
+
+    def on_event(event, &block)
+      # Cannot use self as eval context and
+      # must pass process because after clonning in TCPN it will be
+      # completely different process object then it is now!
+      handler = proc do |process, args|
+        process.functions.each do |name, definition|
+          # This is actually a kind of hack... but there is
+          # no other way to hit exactly this class with define_method, since
+          # almost all other methods from this class are removed by docile.
+          # Therefore every attempt to do metaprogramming on objects of this class
+          # hit the objects to whom this class forwards method calls...
+          # But this way we actually can define required methods that will operate
+          # in the context of proper object representing a process and that will
+          # cause side effects (e.g. changes in event queue) in proper objects.
+          Docile::FallbackContextProxy.__send__ :define_method, name, definition
+        end
+        changed_process = Docile.dsl_eval(ProcessDSL.new(@model, @name, @program, process), args, &block).process
+        process.functions.each do |name, definition|
+          # remove newly defined methods not to mess things up in the Docile::FallbackContextProxy
+          # unless removed, these methods would be available for the other processes!
+          Docile::FallbackContextProxy.__send__ :undef_method
+        end
+        changed_process
+      end
+      @process.on_event(event, &handler)
+    end
+
+    def function(name, &block)
+      @process.function name, &block
+    end
+
+    # register_event name, delay: 100, args: { event related args }
+    def register_event(event, opts = {})
+      args = opts[:args]
+      delay = opts[:delay] || 0
+      @process.enqueue_event(:register_event, event: event, delay: delay, event_args: args)
+    end
+
+    def cpu(&block)
+      @process.enqueue_event(:cpu, block: block)
+    end
+
+    def delay_for(args)
+      if args.kind_of? Numeric
+        args = { time: args }
+      end
+      @process.enqueue_event(:delay_for, args)
+    end
+
+    def send_data(args)
+      @process.enqueue_event(:send_data, args)
+    end
+
+    def log(message)
+      @process.enqueue_event(:log, message)
+    end
+
+    def stats_start(tags)
+      @process.enqueue_event(:stats_start, tags)
+    end
+
+    def stats_stop(tags)
+      @process.enqueue_event(:stats_stop, tags)
+    end
+
+    def stats(tags)
+      @process.enqueue_event(:stats, tags)
+    end
+
+    def stats_save(value, tags)
+      params = { tags: tags, value: value }
+      @process.enqueue_event(:stats_save, params)
+    end
+
+    def new_process(name, args = {}, &block)
+      constructor = proc do |args|
+        new_process = self.class.new_process(@model, name, args, &block)
+        new_process.node = @process.node
+        new_process
+      end
+      @process.enqueue_event(:new_process, constructor_args: args, constructor: constructor)
+    end
+
+    # returns time at which the event occured
+    def event_time
+      @model.simulator.clock
+    end
+  end
+end
+

data/lib/rbsim/dsl/program.rb

@@ -0,0 +1,10 @@
+module RBSim
+  class DSL
+    # program statement just remembers
+    # program's block under specified name,
+    # to be used later when defining/starting processes
+    def program(name, &block)
+      @model.programs[name] = block
+    end
+  end
+end

data/lib/rbsim/experiment.rb

@@ -0,0 +1,110 @@
+# This is a base class to create RBSim based experiment
+# that is able to load your model and start simulation.
+# It encapsulates model, parameters and statistics
+# and also all your methods used to compute simulation results.
+
+require 'pathname'
+
+module RBSim
+
+  class Experiment
+    attr_accessor :file, :params, :time_limit, :data_fragmentation
+    attr_reader :model
+
+    RECORD_SEPARATOR = "__ END OF RECORD __"
+
+    def initialize(params = nil, stats = nil)
+      @params, @stats = params, stats
+    end
+
+    def stats
+      return @stats unless @stats.nil?
+      @stats = model.stats
+    end
+
+    # Run specified model with its params
+    # and collect statistics
+    def run(file, params)
+      read_model(file, params)
+      @model.run
+    end
+
+    # Save statistics to a file
+    def save_stats(file)
+      File.open file, 'a' do |f|
+        f.print Marshal.dump [params, stats]
+        f.print RECORD_SEPARATOR
+      end
+    end
+
+    # Read statistics from a file, return Enumerator of
+    # objects, each opject represents separate experiment
+    def self.read_stats(file, dots = false)
+      size = 0
+      File.open(file) do |file|
+        size = file.each_line(RECORD_SEPARATOR).count
+      end
+
+      e = Enumerator.new size do |y|
+        File.open(file) do |file|
+          begin
+            while !file.eof?
+              file.each_line(RECORD_SEPARATOR) do |line|
+                print "." if dots
+                params, stats = Marshal.restore line
+                y << self.new(params, stats)
+              end
+            end
+          rescue ArgumentError => e
+            raise ArgumentError.new "#{caller.first} got #{e.inspect} after reading #{objects.length} objects!"
+          end
+        end
+      end
+
+      puts if dots
+      e
+    end
+
+    def res_stats
+      stats[:resources]
+    end
+
+    def app_stats
+      stats[:application]
+    end
+
+    private
+
+    def read_model(file, params)
+      @file = file
+      @params = params
+      @model = RBSim.read file, params
+      @model.data_fragmentation = data_fragmentation unless data_fragmentation.nil?
+      @model.tcpn.cb_for :clock, :after, &self.method(:timer)
+      @model.tcpn.cb_for :clock, :after, &self.method(:time_limit_observer)
+    end
+
+    def timer(tag, event)
+      @prev_seconds = 0 if @prev_seconds.nil?
+      @timer_length = 0 if @timer_length.nil?
+
+      seconds = event.clock.in_seconds.truncate
+      if seconds > @prev_seconds
+        print "\b"*@timer_length
+        timer = "Time: #{seconds} sec."
+        print timer
+        @timer_length = timer.length
+      end
+      @prev_seconds = seconds
+    end
+
+    def time_limit_observer(tag, event)
+      return if @time_limit.nil?
+      if event.clock > @time_limit
+        @model.stop
+      end
+    end
+
+  end
+
+end